GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2015 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * XXX:
 *      Better error messages, throughout.
 *      >It also occurred to me that we could link the errors to the error
 *      >documentation.
 *      >
 *      >Unreferenced  function 'request_policy', first mention is
 *      >         Line 8 Pos 4
 *      >         sub request_policy {
 *      >         ----##############--
 *      >Read more about this type of error:
 *      >http://vinyl/doc/error.html#Unreferenced%20function
 *      >
 *      >
 *      >         Unknown variable 'obj.bandwidth'
 *      >         At: Line 88 Pos 12
 *      >                 if (obj.bandwidth < 1 kb/h) {
 *      >         ------------#############------------
 *      >Read more about this type of error:
 *      >http://vinyl/doc/error.html#Unknown%20variable
 *
 */

#include "config.h"

#include <fcntl.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "vcc_compile.h"

#include "libvcc.h"
#include "vfil.h"
#include "vct.h"

static const struct method method_tab[] = {
        { "none", 0U, 0},
#define VCL_MET_MAC(l,U,t,b)    { "vcl_"#l, b, VCL_MET_##U },
#include "tbl/vcl_returns.h"
        { NULL, 0U, 0}
};

struct vcc *vcc_builtin;

/*--------------------------------------------------------------------*/

static void
vcc_vcl_met2c(struct vsb *vsb, unsigned method)
{
        int d = 0;

        //lint -e{774} Boolean within 'if' always evaluates to False
#define VCL_MET_MAC(l,U,t,b)                            \
        do {                                            \
                if (method & VCL_MET_##U) {             \
                        if (d)                          \
                                VSB_putc(vsb, '|');     \
                        VSB_cat(vsb, "VCL_MET_" #U);    \
                        d = 1;                          \
                }                                       \
        } while (0);
#include "tbl/vcl_returns.h"
        AN(d);
}


/*--------------------------------------------------------------------*/

void * v_matchproto_(TlAlloc)
TlAlloc(struct vcc *tl, unsigned len)
{
        void *p;

        (void)tl;
        p = calloc(1, len);
        assert(p != NULL);
        return (p);
}

char *
TlDup(struct vcc *tl, const char *s)
{
        char *p;

        p = TlAlloc(tl, vstrlen(s) + 1);
        AN(p);
        strcpy(p, s);
        return (p);
}

static int
TLWriteVSB(struct vcc *tl, const char *fn, const struct vsb *vsb,
    const char *what)
{
        int fo;
        int i;

        fo = open(fn, O_WRONLY|O_TRUNC|O_CREAT, 0600);
        if (fo < 0) {
                VSB_printf(tl->sb,
                    "Could not open %s file %s: %s\n",
                    what, fn, strerror(errno));
                return (-1);
        }
        i = VSB_tofile(vsb, fo);
        if (i) {
                VSB_printf(tl->sb,
                    "Could not write %s to %s: %s\n",
                    what, fn, strerror(errno));
        }
        closefd(&fo);
        return (i);
}

/*--------------------------------------------------------------------*/

static void
vcc_refUnusedProbes(struct vcc *tl, const struct symbol *sym)
{
        if (sym->ndef != 0 && sym->nref == 0)
                Fc(tl, 0, "\t(void)%s;\n", sym->rname);
}

struct proc *
vcc_NewProc(struct vcc *tl, struct symbol *sym)
{
        struct proc *p;

        ALLOC_OBJ(p, PROC_MAGIC);
        AN(p);
        VTAILQ_INIT(&p->calls);
        VTAILQ_INIT(&p->uses);
        VTAILQ_INSERT_TAIL(&tl->procs, p, list);
        p->prologue = VSB_new_auto();
        AN(p->prologue);
        p->body = VSB_new_auto();
        AN(p->body);
        p->cname = VSB_new_auto();
        AN(p->cname);
        p->okmask = VCL_MET_TASK_ALL;
        sym->proc = p;
        p->sym = sym;
        return (p);
}

static void
vcc_EmitProc(struct vcc *tl, struct proc *p)
{
        struct vsb *vsbm;
        unsigned mask, nsub;
        const char *maskcmp;
        const char *cc_adv;
        int dyn = (p->sym->nref > p->called);

        AN(p->okmask);
        AZ(VSB_finish(p->cname));
        AZ(VSB_finish(p->prologue));
        AZ(VSB_finish(p->body));
        AN(p->sym);

        if (p->method) {
                mask = p->method->bitval;
                maskcmp = "==";
        } else {
                mask = p->okmask;
                maskcmp = "&";
        }

        if (dyn == 0 && (p->calledfrom & VCL_MET_TASK_H) == p->calledfrom)
                cc_adv = "v_dont_optimize ";
        else
                cc_adv = "";

        nsub = tl->nsub++;

        Fh(tl, 1, "vcl_func_f %s;\n", VSB_data(p->cname));
        Fh(tl, 1, "extern const struct vcl_sub sub_%s[1];\n",
            VSB_data(p->cname));
        Fh(tl, 1, "const struct vcl_sub sub_%s[1] = {{\n", VSB_data(p->cname));
        Fh(tl, 1, "\t.magic\t\t= VCL_SUB_MAGIC,\n");
        Fh(tl, 1, "\t.methods\t= 0x%x,\n", p->okmask);
        Fh(tl, 1, "\t.name\t\t= \"%.*s\",\n", PF(p->name));
        Fh(tl, 1, "\t.vcl_conf\t= &VCL_conf,\n");
        Fh(tl, 1, "\t.func\t\t= %s,\n", VSB_data(p->cname));
        Fh(tl, 1, "\t.n\t\t= %d,\n", nsub);
        Fh(tl, 1, "\t.nref\t\t= %d,\n", p->sym->nref);
        Fh(tl, 1, "\t.called\t\t= %d\n", p->called);
        Fh(tl, 1, "\t// calledfrom\t  0x%x\n", p->calledfrom);
        Fh(tl, 1, "}};\n");

        if (dyn) {
                Fc(tl, 1, "\nstatic inline void %s\n", cc_adv);
                Fc(tl, 1, "%s_checked(VRT_CTX)\n{\n", VSB_data(p->cname));
        } else {
                Fc(tl, 1, "\nvoid %sv_matchproto_(vcl_func_f)\n", cc_adv);
                Fc(tl, 1, "%s(VRT_CTX, enum vcl_func_call_e call,\n",
                    VSB_data(p->cname));
                Fc(tl, 1, "    enum vcl_func_fail_e *failp)\n{\n");
                Fc(tl, 1, "  assert(call == VSUB_STATIC);\n");
                Fc(tl, 1, "  assert(failp == NULL);\n");
        }

        vsbm = VSB_new_auto();
        AN(vsbm);
        vcc_vcl_met2c(vsbm, mask);
        AZ(VSB_finish(vsbm));
        Fc(tl, 1, "  assert(ctx->method %s (%s));\n", maskcmp, VSB_data(vsbm));
        VSB_destroy(&vsbm);
        Fc(tl, 1, "%s\n%s}\n", VSB_data(p->prologue), VSB_data(p->body));
        VSB_destroy(&p->body);
        VSB_destroy(&p->prologue);

        if (! dyn) {
                VSB_destroy(&p->cname);
                return;
        }

        /* wrapper to call the actual (_checked) function */
        Fc(tl, 1, "\nvoid v_matchproto_(vcl_func_f)\n");
        Fc(tl, 1, "%s(VRT_CTX, enum vcl_func_call_e call,\n",
            VSB_data(p->cname));
        Fc(tl, 1, "    enum vcl_func_fail_e *failp)\n{\n");
        Fc(tl, 1, "  enum vcl_func_fail_e fail;\n\n");
        Fc(tl, 1, "  fail = VPI_Call_Check(ctx, &VCL_conf, 0x%x, %d);\n",
            mask, nsub);
        Fc(tl, 1, "  if (failp)\n");
        Fc(tl, 1, "    *failp = fail;\n");
        Fc(tl, 1, "  else if (fail == VSUB_E_METHOD)\n");
        Fc(tl, 1, "    VRT_fail(ctx, \"call to \\\"sub %.*s{}\\\""
            " not allowed from here\");\n", PF(p->name));
        Fc(tl, 1, "  else if (fail == VSUB_E_RECURSE)\n");
        Fc(tl, 1, "    VRT_fail(ctx, \"Recursive call to "
            "\\\"sub %.*s{}\\\"\");\n", PF(p->name));
        Fc(tl, 1, "  else\n");
        Fc(tl, 1, "    assert (fail == VSUB_E_OK);\n");
        Fc(tl, 1, "  if (fail != VSUB_E_OK || call == VSUB_CHECK)\n");
        Fc(tl, 1, "    return;\n");
        Fc(tl, 1, "  VPI_Call_Begin(ctx, %d);\n", nsub);
        Fc(tl, 1, "  %s_checked(ctx);\n", VSB_data(p->cname));
        Fc(tl, 1, "  VPI_Call_End(ctx, %d);\n", nsub);
        Fc(tl, 1, "}\n");
        VSB_destroy(&p->cname);
}

/*--------------------------------------------------------------------*/

struct inifin *
New_IniFin(struct vcc *tl)
{
        struct inifin *p;

        ALLOC_OBJ(p, INIFIN_MAGIC);
        AN(p);
        p->ini = VSB_new_auto();
        AN(p->ini);
        p->fin = VSB_new_auto();
        AN(p->fin);
        p->final = VSB_new_auto();
        AN(p->final);
        p->event = VSB_new_auto();
        AN(p->event);
        p->n = ++tl->ninifin;
        VTAILQ_INSERT_TAIL(&tl->inifin, p, list);
        return (p);
}

/*--------------------------------------------------------------------
 * Printf output to the vsbs, possibly indented
 */

void
Fh(const struct vcc *tl, int indent, const char *fmt, ...)
{
        va_list ap;

        if (indent)
                VSB_printf(tl->fh, "%*.*s", tl->hindent, tl->hindent, "");
        va_start(ap, fmt);
        VSB_vprintf(tl->fh, fmt, ap);
        va_end(ap);
}

void
Fb(const struct vcc *tl, int indent, const char *fmt, ...)
{
        va_list ap;

        assert(tl->fb != NULL);
        if (indent)
                VSB_printf(tl->fb, "%*.*s", tl->indent, tl->indent, "");
        va_start(ap, fmt);
        VSB_vprintf(tl->fb, fmt, ap);
        va_end(ap);
}

void
Fc(const struct vcc *tl, int indent, const char *fmt, ...)
{
        va_list ap;

        if (indent)
                VSB_printf(tl->fc, "%*.*s", tl->indent, tl->indent, "");
        va_start(ap, fmt);
        VSB_vprintf(tl->fc, fmt, ap);
        va_end(ap);
}

/*--------------------------------------------------------------------*/

void
EncToken(struct vsb *sb, const struct token *t)
{

        assert(t->tok == CSTR);
        VSB_quote(sb, t->dec, -1, VSB_QUOTE_CSTR);
}

/*--------------------------------------------------------------------
 * Output the location/profiling table.  For each counted token, we
 * record source+line+charpos for the first character in the token.
 */

static void
EmitCoordinates(const struct vcc *tl, struct vsb *vsb)
{
        struct token *t;
        unsigned lin, pos;
        const struct source *sp;
        const char *p;

        VSB_cat(vsb, "/* ---===### Source Code ###===---*/\n");

        VSB_printf(vsb, "\n#define VGC_NSRCS %u\n", tl->nsources);

        VSB_cat(vsb, "\nstatic const char *srcname[VGC_NSRCS] = {\n");
        VTAILQ_FOREACH(sp, &tl->sources, list) {
                VSB_cat(vsb, "\t");
                VSB_quote(vsb, sp->name, -1, VSB_QUOTE_CSTR);
                VSB_cat(vsb, ",\n");
        }
        VSB_cat(vsb, "};\n");

        VSB_printf(vsb, "\nstatic const char *srcbody[%u] = {\n", tl->nsources);
        VTAILQ_FOREACH(sp, &tl->sources, list) {
                VSB_cat(vsb, "    /* ");
                VSB_quote(vsb, sp->name, -1, VSB_QUOTE_CSTR);
                VSB_cat(vsb, " */\n");
                VSB_quote_pfx(vsb, "\t", sp->b, sp->e - sp->b, VSB_QUOTE_CSTR);
                VSB_cat(vsb, ",\n");
        }
        VSB_cat(vsb, "};\n\n");

        VSB_cat(vsb, "/* ---===### Location Counters ###===---*/\n");

        VSB_printf(vsb, "\n#define VGC_NREFS %u\n\n", tl->cnt + 1);

        VSB_cat(vsb, "static const struct vpi_ref VGC_ref[VGC_NREFS] = {\n");
        lin = 1;
        pos = 0;
        sp = 0;
        p = NULL;
        VTAILQ_FOREACH(t, &tl->tokens, list) {
                if (t->cnt == 0)
                        continue;
                assert(t->src != NULL);
                if (t->src != sp) {
                        lin = 1;
                        pos = 0;
                        sp = t->src;
                        p = sp->b;
                }
                assert(sp != NULL);
                assert(p != NULL);
                for (;p < t->b; p++) {
                        if (*p == '\n') {
                                lin++;
                                pos = 0;
                        } else if (*p == '\t') {
                                pos &= ~7;
                                pos += 8;
                        } else
                                pos++;

                }
                VSB_printf(vsb, "  [%3u] = { VPI_REF_MAGIC, %u, %8tu, %4u, %3u, ",
                    t->cnt, sp->idx, t->b - sp->b, lin, pos + 1);
                if (t->tok == CSRC)
                        VSB_cat(vsb, " \"C{\"},\n");
                else
                        VSB_printf(vsb, " \"%.*s\" },\n", PF(t));
        }
        VSB_cat(vsb, "};\n\n");
}

/*--------------------------------------------------------------------
 * Init/Fini/Event
 *
 * We call DISCARD and COLD events in the opposite order of LOAD and
 * WARM.
 */

static void
EmitInitFini(struct vcc *tl)
{
        struct inifin *p, *q = NULL;
        unsigned has_event = 0;
        struct symbol *sy;

        Fh(tl, 0, "\n");
        Fh(tl, 0, "static unsigned vgc_inistep;\n");
        Fh(tl, 0, "static unsigned vgc_warmupstep;\n");

        /*
         * LOAD
         */
        Fc(tl, 0, "\nstatic int\nVGC_Load(VRT_CTX)\n{\n\n");
        Fc(tl, 0, "\tvgc_inistep = 0;\n");
        Fc(tl, 0, "\tsize_t ndirector = %dUL;\n", tl->ndirector);
        Fc(tl, 0, "\n");
        VTAILQ_FOREACH(p, &tl->inifin, list) {
                AZ(VSB_finish(p->ini));
                assert(p->n > 0);
                if (VSB_len(p->ini))
                        Fc(tl, 0, "\t/* %u */\n%s\n", p->n, VSB_data(p->ini));
                if (p->ignore_errors == 0) {
                        Fc(tl, 0, "\tif (ctx->vpi->handling == VCL_RET_FAIL)\n");
                        Fc(tl, 0, "\t\treturn(1);\n");
                }
                Fc(tl, 0, "\tvgc_inistep = %u;\n\n", p->n);
                VSB_destroy(&p->ini);

                AZ(VSB_finish(p->event));
                if (VSB_len(p->event))
                        has_event = 1;
        }

        /* Handle failures from vcl_init */
        Fc(tl, 0, "\n");
        Fc(tl, 0, "\tif (ctx->vpi->handling != VCL_RET_OK)\n");
        Fc(tl, 0, "\t\treturn(1);\n");
        Fc(tl, 0, "\tctx->vpi->handling = 0;\n");

        VTAILQ_FOREACH(sy, &tl->sym_objects, sideways) {
                Fc(tl, 0, "\tif (!%s) {\n", sy->rname);
                Fc(tl, 0, "\t\tVRT_fail(ctx, "
                    "\"Object %s not initialized\");\n" , sy->name);
                Fc(tl, 0, "\t\treturn(1);\n");
                Fc(tl, 0, "\t}\n");
        }

        Fc(tl, 0, "\treturn(0);\n");
        Fc(tl, 0, "}\n");

        /*
         * DISCARD
         */
        Fc(tl, 0, "\nstatic int\nVGC_Discard(VRT_CTX)\n{\n\n");

        Fc(tl, 0, "\tswitch (vgc_inistep) {\n");
        VTAILQ_FOREACH_REVERSE(p, &tl->inifin, inifinhead, list) {
                AZ(VSB_finish(p->fin));
                if (q)
                        assert(q->n > p->n);
                q = p;
                Fc(tl, 0, "\t\tcase %u:\n", p->n);
                if (VSB_len(p->fin))
                        Fc(tl, 0, "\t%s\n", VSB_data(p->fin));
                Fc(tl, 0, "\t\t\t/* FALLTHROUGH */\n");
                VSB_destroy(&p->fin);
        }
        Fc(tl, 0, "\t\tdefault:\n\t\t\tbreak;\n");
        Fc(tl, 0, "\t}\n\n");
        Fc(tl, 0, "\tswitch (vgc_inistep) {\n");
        VTAILQ_FOREACH_REVERSE(p, &tl->inifin, inifinhead, list) {
                AZ(VSB_finish(p->final));
                Fc(tl, 0, "\t\tcase %u:\n", p->n);
                if (VSB_len(p->final))
                        Fc(tl, 0, "\t%s\n", VSB_data(p->final));
                Fc(tl, 0, "\t\t\t/* FALLTHROUGH */\n");
                VSB_destroy(&p->final);
        }
        Fc(tl, 0, "\t\tdefault:\n\t\t\tbreak;\n");
        Fc(tl, 0, "\t}\n\n");

        Fc(tl, 0, "\treturn (0);\n");
        Fc(tl, 0, "}\n");

        if (has_event) {
                /*
                 * WARM
                 */
                Fc(tl, 0, "\nstatic int\n");
                Fc(tl, 0, "VGC_Warmup(VRT_CTX, enum vcl_event_e ev)\n{\n\n");

                Fc(tl, 0, "\tvgc_warmupstep = 0;\n\n");
                VTAILQ_FOREACH(p, &tl->inifin, list) {
                        assert(p->n > 0);
                        if (VSB_len(p->event)) {
                                Fc(tl, 0, "\t/* %u */\n", p->n);
                                Fc(tl, 0, "\tif (%s)\n", VSB_data(p->event));
                                Fc(tl, 0, "\t\treturn (1);\n");
                                Fc(tl, 0, "\tvgc_warmupstep = %u;\n\n", p->n);
                        }
                }

                Fc(tl, 0, "\treturn (0);\n");
                Fc(tl, 0, "}\n");

                /*
                 * COLD
                 */
                Fc(tl, 0, "\nstatic int\n");
                Fc(tl, 0, "VGC_Cooldown(VRT_CTX, enum vcl_event_e ev)\n{\n");
                Fc(tl, 0, "\tint retval = 0;\n\n");

                VTAILQ_FOREACH_REVERSE(p, &tl->inifin, inifinhead, list) {
                        if (VSB_len(p->event)) {
                                Fc(tl, 0, "\t/* %u */\n", p->n);
                                Fc(tl, 0,
                                    "\tif (vgc_warmupstep >= %u &&\n", p->n);
                                Fc(tl, 0,
                                    "\t    %s != 0)\n", VSB_data(p->event));
                                Fc(tl, 0, "\t\tretval = 1;\n\n");
                        }
                        VSB_destroy(&p->event);
                }

                Fc(tl, 0, "\treturn (retval);\n");
                Fc(tl, 0, "}\n");
        }

        /*
         * EVENTS
         */
        Fc(tl, 0, "\nstatic int\n");
        Fc(tl, 0, "VGC_Event(VRT_CTX, enum vcl_event_e ev)\n");
        Fc(tl, 0, "{\n");
        Fc(tl, 0, "\tif (ev == VCL_EVENT_LOAD)\n");
        Fc(tl, 0, "\t\treturn (VGC_Load(ctx));\n");
        if (has_event) {
                Fc(tl, 0, "\tif (ev == VCL_EVENT_WARM)\n");
                Fc(tl, 0, "\t\treturn (VGC_Warmup(ctx, ev));\n");
                Fc(tl, 0, "\tif (ev == VCL_EVENT_COLD)\n");
                Fc(tl, 0, "\t\treturn (VGC_Cooldown(ctx, ev));\n");
        }
        Fc(tl, 0, "\tif (ev == VCL_EVENT_DISCARD)\n");
        Fc(tl, 0, "\t\treturn (VGC_Discard(ctx));\n");
        Fc(tl, 0, "\tassert(ev != VDI_EVENT_SICK);\n");
        Fc(tl, 0, "\n");
        if (!has_event)
                Fc(tl, 0, "\t(void)vgc_warmupstep;\n");
        VCC_WalkSymbols(tl, vcc_refUnusedProbes, SYM_MAIN, SYM_PROBE);
        Fc(tl, 0, "\treturn (%d);\n", has_event ? 1 : 0);
        Fc(tl, 0, "}\n");
}

/*--------------------------------------------------------------------*/

static void
EmitStruct(const struct vcc *tl)
{
        Fc(tl, 0, "\nconst struct VCL_conf VCL_conf = {\n");
        Fc(tl, 0, "\t.magic = VCL_CONF_MAGIC,\n");
        Fc(tl, 0, "\t.syntax = %u,\n", tl->syntax);
        Fc(tl, 0, "\t.event_vcl = VGC_Event,\n");
        Fc(tl, 0, "\t.default_director = &%s,\n", tl->default_director);
        if (tl->default_probe != NULL)
                Fc(tl, 0, "\t.default_probe = %s,\n", tl->default_probe);
        Fc(tl, 0, "\t.ref = VGC_ref,\n");
        Fc(tl, 0, "\t.nref = VGC_NREFS,\n");
        Fc(tl, 0, "\t.nsrc = VGC_NSRCS,\n");
        Fc(tl, 0, "\t.nsub = %d,\n", tl->subref > 0 ? tl->nsub : 0);
        Fc(tl, 0, "\t.srcname = srcname,\n");
        Fc(tl, 0, "\t.srcbody = srcbody,\n");
        Fc(tl, 0, "\t.nvmod = %u,\n", tl->vmod_count);
#define VCL_MET_MAC(l,u,t,b) \
        Fc(tl, 0, "\t." #l "_func = VGC_function_vcl_" #l ",\n");
#include "tbl/vcl_returns.h"
        Fc(tl, 0, "\t.instance_info = VGC_instance_info\n");
        Fc(tl, 0, "};\n");
}

/*--------------------------------------------------------------------
 * Compile the VCL code from the given source and return the C-source
 */

static struct vsb *
vcc_CompileSource(struct vcc *tl, struct source *sp, const char *jfile)
{
        struct proc *p;
        struct vsb *vsb;
        struct inifin *ifp;

        Fh(tl, 0, "/* ---===### VCC generated .h code ###===---*/\n");
        Fc(tl, 0, "\n/* ---===### VCC generated .c code ###===---*/\n");

        Fc(tl, 0, "\n#define END_ if (ctx->vpi->handling) return\n");

        vcc_Parse_Init(tl);

        vcc_Expr_Init(tl);

        vcc_Action_Init(tl);

        vcc_Backend_Init(tl);

        vcc_Var_Init(tl);

        vcc_Type_Init(tl);

        Fh(tl, 0, "\nextern const struct VCL_conf VCL_conf;\n");

        /* Register and lex the main source */
        if (sp != NULL) {
                AN(vcc_builtin);
                vcc_lex_source(tl, sp, 0);
                if (tl->err)
                        return (NULL);
        }

        /* Register and lex the builtin VCL */
        sp = vcc_new_source(tl->builtin_vcl, "builtin", "<builtin>");
        assert(sp != NULL);
        vcc_lex_source(tl, sp, 1);
        if (tl->err)
                return (NULL);

        /* Parse the token string */
        tl->t = VTAILQ_FIRST(&tl->tokens);
        vcc_Parse(tl);
        if (tl->err)
                return (NULL);

        /* Check for orphans */
        if (vcc_CheckReferences(tl))
                return (NULL);

        /* Check that all action returns are legal */
        if (vcc_CheckAction(tl) || tl->err)
                return (NULL);

        /* Check that all variable uses are legal */
        if (vcc_CheckUses(tl) || tl->err)
                return (NULL);

        if (vcc_builtin == NULL)
                return (NULL);

        /* Check if we have any backends at all */
        if (tl->default_director == NULL) {
                VSB_cat(tl->sb,
                    "No backends or directors found in VCL program, "
                    "at least one is necessary.\n");
                tl->err = 1;
                return (NULL);
        }

        /* Tie vcl_init/fini in */
        ifp = New_IniFin(tl);
        VSB_cat(ifp->ini, "\tVGC_function_vcl_init(ctx, VSUB_STATIC, NULL);\n");
        /*
         * Because the failure could be half way into vcl_init{} so vcl_fini{}
         * must always be called, also on failure.
         */
        ifp->ignore_errors = 1;
        VSB_cat(ifp->fin, "\t\tVGC_function_vcl_fini(ctx, VSUB_STATIC, NULL);\n");
        VSB_cat(ifp->fin, "\t\t\tVPI_vcl_fini(ctx);");

        /* Emit method functions */
        Fh(tl, 1, "\n");
        VTAILQ_FOREACH(p, &tl->procs, list)
                if (p->method == NULL)
                        vcc_EmitProc(tl, p);
        VTAILQ_FOREACH(p, &tl->procs, list)
                if (p->method != NULL)
                        vcc_EmitProc(tl, p);

        EmitInitFini(tl);

        VCC_InstanceInfo(tl);

        EmitStruct(tl);

        VCC_XrefTable(tl);

        VSB_cat(tl->symtab, "\n]\n");
        AZ(VSB_finish(tl->symtab));
        if (TLWriteVSB(tl, jfile, tl->symtab, "Symbol table"))
                return (NULL);

        /* Combine it all */

        vsb = VSB_new_auto();
        AN(vsb);

        vcl_output_lang_h(vsb);

        EmitCoordinates(tl, vsb);

        AZ(VSB_finish(tl->fh));
        VSB_cat(vsb, VSB_data(tl->fh));

        AZ(VSB_finish(tl->fc));
        VSB_cat(vsb, VSB_data(tl->fc));

        AZ(VSB_finish(vsb));
        return (vsb);
}

static struct vcc *
vcc_ParseBuiltin(struct vcc *tl)
{
        struct vcc *tl_builtin;

        CHECK_OBJ_NOTNULL(tl, VCC_MAGIC);
        tl_builtin = VCC_New();
        AN(tl_builtin);
        VCC_Builtin_VCL(tl_builtin, tl->builtin_vcl);
        AZ(vcc_CompileSource(tl_builtin, NULL, NULL));
        return (tl_builtin);
}

/*--------------------------------------------------------------------
 * Report the range of VCL language we support
 */
void
VCC_VCL_Range(unsigned *lo, unsigned *hi)
{

        AN(lo);
        *lo = VCL_LOW;
        AN(hi);
        *hi = VCL_HIGH;
}

/*--------------------------------------------------------------------
 * Compile the VCL code in the argument.  Error messages, if any are
 * formatted into the vsb.
 */

int
VCC_Compile(struct vcc *tl, struct vsb **sb,
    const char *vclsrc, const char *vclsrcfile,
    const char *ofile, const char *jfile)
{
        struct source *sp;
        struct vsb *r = NULL;
        int retval = 0;

        CHECK_OBJ_NOTNULL(tl, VCC_MAGIC);
        AN(sb);
        AN(vclsrcfile);
        AN(ofile);
        AN(jfile);

        AZ(vcc_builtin);
        vcc_builtin = vcc_ParseBuiltin(tl);
        AN(vcc_builtin);
        if (vcc_builtin->err) {
                AZ(VSB_finish(vcc_builtin->sb));
                *sb = vcc_builtin->sb;
                return (-1);
        }

        if (vclsrc != NULL)
                sp = vcc_new_source(vclsrc, "vcl.inline", vclsrcfile);
        else
                sp = vcc_file_source(tl, vclsrcfile);

        if (sp != NULL)
                r = vcc_CompileSource(tl, sp, jfile);

        if (r != NULL) {
                retval = TLWriteVSB(tl, ofile, r, "C-source");
                VSB_destroy(&r);
        } else {
                retval = -1;
        }
        AZ(VSB_finish(tl->sb));
        *sb = tl->sb;
        return (retval);
}

/*--------------------------------------------------------------------
 * Allocate a compiler instance
 */

struct vcc *
VCC_New(void)
{
        struct vcc *tl;
        struct symbol *sym;
        struct proc *p;
        struct vsb *vsb;
        int i;

        ALLOC_OBJ(tl, VCC_MAGIC);
        AN(tl);
        VTAILQ_INIT(&tl->inifin);
        VTAILQ_INIT(&tl->tokens);
        VTAILQ_INIT(&tl->sources);
        VTAILQ_INIT(&tl->procs);
        VTAILQ_INIT(&tl->sym_objects);
        VTAILQ_INIT(&tl->sym_vmods);
        VTAILQ_INIT(&tl->vmod_objects);

        tl->nsources = 0;

        tl->symtab = VSB_new_auto();
        assert(tl->symtab != NULL);
        VSB_cat(tl->symtab, "[\n    {\"version\": 0}");

        tl->fc = VSB_new_auto();
        assert(tl->fc != NULL);

        tl->fh = VSB_new_auto();
        assert(tl->fh != NULL);

        for (i = 1; i < VCL_MET_MAX; i++) {
                sym = VCC_MkSym(tl, method_tab[i].name,
                    SYM_MAIN, SYM_SUB, VCL_LOW, VCL_HIGH);
                p = vcc_NewProc(tl, sym);
                p->method = &method_tab[i];

                // see also VCC_GlobalSymbol()
                vsb = VSB_new_auto();
                AN(vsb);
                VSB_printf(vsb, "%s_%s", SUB->global_pfx, p->method->name);
                AZ(VSB_finish(vsb));

                AZ(VSB_bcat(p->cname, VSB_data(vsb), VSB_len(vsb)));

                sym->lname = strdup(VSB_data(vsb));
                AN(sym->lname);

                VSB_clear(vsb);
                VSB_printf(vsb, "sub_%s", sym->lname);
                AZ(VSB_finish(vsb));

                sym->rname = strdup(VSB_data(vsb));
                AN(sym->rname);
                VSB_destroy(&vsb);

                sym->type = SUB;
                sym->kind = VCC_HandleKind(SUB);
                AZ(VCT_invalid_name(sym->rname, NULL));
                sym->eval = vcc_Eval_Sub;
        }
        tl->sb = VSB_new_auto();
        AN(tl->sb);
        return (tl);
}

/*--------------------------------------------------------------------
 * Configure builtin VCL source code
 */

void
VCC_Builtin_VCL(struct vcc *vcc, const char *str)
{

        CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);
        REPLACE(vcc->builtin_vcl, str);
}

/*--------------------------------------------------------------------
 * Configure default VCL source path
 */

void
VCC_VCL_path(struct vcc *vcc, const char *str)
{

        CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);
        VFIL_setpath(&vcc->vcl_path, str);
}

/*--------------------------------------------------------------------
 * Configure default VMOD path
 */

void
VCC_VMOD_path(struct vcc *vcc, const char *str)
{

        CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);
        VFIL_setpath(&vcc->vmod_path, str);
}

/*--------------------------------------------------------------------
 * Configure settings
 */

#define VCC_FEATURE_BIT(U, l, d)                                \
        void VCC_Opt_ ## l(struct vcc *vcc, unsigned val)       \
        {                                                       \
                CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);              \
                vcc->l = val;                                   \
        }
#include "tbl/vcc_feature_bits.h"

/*--------------------------------------------------------------------
 * Configure settings
 */

static void
vcc_predef_vcl(struct vcc *vcc, const char *name)
{
        struct symbol *sym;

        sym = VCC_MkSym(vcc, name, SYM_MAIN, SYM_VCL, VCL_LOW, VCL_HIGH);
        AN(sym);
        sym->type = VCL;
        sym->r_methods = VCL_MET_RECV;
}

void
VCC_Predef(struct vcc *vcc, const char *type, const char *name)
{

        CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);
        if (!vstrcmp(type, "VCL_STEVEDORE"))
                vcc_stevedore(vcc, name);
        else if (!vstrcmp(type, "VCL_VCL"))
                vcc_predef_vcl(vcc, name);
        else
                WRONG("Unknown VCC predef type");
}

void
VCC_VEXT(struct vcc *vcc, const char *filename)
{
        CHECK_OBJ_NOTNULL(vcc, VCC_MAGIC);
        vcc_ImportVext(vcc, filename);
}

		vinyl-cache/lib/libvcc/vcc_compile.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2015 Varnish Software AS
3		* All rights reserved.
4		*
5		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6		*
7		* SPDX-License-Identifier: BSD-2-Clause
8		*
9		* Redistribution and use in source and binary forms, with or without
10		* modification, are permitted provided that the following conditions
11		* are met:
12		* 1. Redistributions of source code must retain the above copyright
13		* notice, this list of conditions and the following disclaimer.
14		* 2. Redistributions in binary form must reproduce the above copyright
15		* notice, this list of conditions and the following disclaimer in the
16		* documentation and/or other materials provided with the distribution.
17		*
18		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28		* SUCH DAMAGE.
29		*/
30
31		/*
32		* XXX:
33		* Better error messages, throughout.
34		* >It also occurred to me that we could link the errors to the error
35		* >documentation.
36		* >
37		* >Unreferenced function 'request_policy', first mention is
38		* > Line 8 Pos 4
39		* > sub request_policy {
40		* > ----##############--
41		* >Read more about this type of error:
42		* >http://vinyl/doc/error.html#Unreferenced%20function
43		* >
44		* >
45		* > Unknown variable 'obj.bandwidth'
46		* > At: Line 88 Pos 12
47		* > if (obj.bandwidth < 1 kb/h) {
48		* > ------------#############------------
49		* >Read more about this type of error:
50		* >http://vinyl/doc/error.html#Unknown%20variable
51		*
52		*/
53
54		#include "config.h"
55
56		#include <fcntl.h>
57		#include <stdarg.h>
58		#include <stdlib.h>
59		#include <string.h>
60		#include <unistd.h>
61
62		#include "vcc_compile.h"
63
64		#include "libvcc.h"
65		#include "vfil.h"
66		#include "vct.h"
67
68		static const struct method method_tab[] = {
69		{ "none", 0U, 0},
70		#define VCL_MET_MAC(l,U,t,b) { "vcl_"#l, b, VCL_MET_##U },
71		#include "tbl/vcl_returns.h"
72		{ NULL, 0U, 0}
73		};
74
75		struct vcc *vcc_builtin;
76
77		/--------------------------------------------------------------------/
78
79		static void
80	1217307	vcc_vcl_met2c(struct vsb *vsb, unsigned method)
81		{
82	1217307	int d = 0;
83
84		//lint -e{774} Boolean within 'if' always evaluates to False
85		#define VCL_MET_MAC(l,U,t,b) \
86		do { \
87		if (method & VCL_MET_##U) { \
88		if (d) \
89		VSB_putc(vsb, '\|'); \
90		VSB_cat(vsb, "VCL_MET_" #U); \
91		d = 1; \
92		} \
93		} while (0);
94		#include "tbl/vcl_returns.h"
95	1217307	AN(d);
96		}
97
98
99		/--------------------------------------------------------------------/
100
101		void * v_matchproto_(TlAlloc)
102	101736783	TlAlloc(struct vcc *tl, unsigned len)
103		{
104		void *p;
105
106	101736783	(void)tl;
107	101736783	p = calloc(1, len);
108	101736783	assert(p != NULL);
109	101736783	return (p);
110		}
111
112		char *
113	4981437	TlDup(struct vcc tl, const char s)
114		{
115		char *p;
116
117	4981437	p = TlAlloc(tl, vstrlen(s) + 1);
118	4981437	AN(p);
119	4981437	strcpy(p, s);
120	4981437	return (p);
121		}
122
123		static int
124	55272	TLWriteVSB(struct vcc tl, const char fn, const struct vsb *vsb,
125		const char *what)
126		{
127	1217307	int fo;
128		int i;
129
130	55272	fo = open(fn, O_WRONLY\|O_TRUNC\|O_CREAT, 0600);
131	55272	if (fo < 0) {
132	0	VSB_printf(tl->sb,
133		"Could not open %s file %s: %s\n",
134	1217307	what, fn, strerror(errno));
135	0	return (-1);
136		}
137	55272	i = VSB_tofile(vsb, fo);
138	55272	if (i) {
139	0	VSB_printf(tl->sb,
140		"Could not write %s to %s: %s\n",
141	1217307	what, fn, strerror(errno));
142	0	}
143	55272	closefd(&fo);
144	55272	return (i);
145	55272	}
146
147		/--------------------------------------------------------------------/
148
149		static void
150	294	vcc_refUnusedProbes(struct vcc tl, const struct symbol sym)
151	1217307	{
152	294	if (sym->ndef != 0 && sym->nref == 0)
153	21	Fc(tl, 0, "\t(void)%s;\n", sym->rname);
154	294	}
155
156		struct proc *
157	2856760	vcc_NewProc(struct vcc tl, struct symbol sym)
158		{
159		struct proc *p;
160	1217307
161	2856760	ALLOC_OBJ(p, PROC_MAGIC);
162	2856760	AN(p);
163	2856760	VTAILQ_INIT(&p->calls);
164	2856760	VTAILQ_INIT(&p->uses);
165	2856760	VTAILQ_INSERT_TAIL(&tl->procs, p, list);
166	2856760	p->prologue = VSB_new_auto();
167	4074067	AN(p->prologue);
168	2856760	p->body = VSB_new_auto();
169	2856760	AN(p->body);
170	2856760	p->cname = VSB_new_auto();
171	4074067	AN(p->cname);
172	2856760	p->okmask = VCL_MET_TASK_ALL;
173	2856760	sym->proc = p;
174	2856760	p->sym = sym;
175	2856760	return (p);
176	1217307	}
177
178		static void
179	1217307	vcc_EmitProc(struct vcc tl, struct proc p)
180		{
181		struct vsb *vsbm;
182		unsigned mask, nsub;
183		const char *maskcmp;
184	1217307	const char *cc_adv;
185	1217307	int dyn = (p->sym->nref > p->called);
186
187	1217307	AN(p->okmask);
188	1217307	AZ(VSB_finish(p->cname));
189	2434614	AZ(VSB_finish(p->prologue));
190	1217307	AZ(VSB_finish(p->body));
191	1217307	AN(p->sym);
192
193	1217307	if (p->method) {
194	414540	mask = p->method->bitval;
195	414540	maskcmp = "==";
196	414540	} else {
197	2020074	mask = p->okmask;
198	802767	maskcmp = "&";
199		}
200
201	1217307	if (dyn == 0 && (p->calledfrom & VCL_MET_TASK_H) == p->calledfrom)
202	55545	cc_adv = "v_dont_optimize ";
203		else
204	2379069	cc_adv = "";
205
206	1217307	nsub = tl->nsub++;
207
208	1217307	Fh(tl, 1, "vcl_func_f %s;\n", VSB_data(p->cname));
209	2434614	Fh(tl, 1, "extern const struct vcl_sub sub_%s[1];\n",
210	2434614	VSB_data(p->cname));
211	1217307	Fh(tl, 1, "const struct vcl_sub sub_%s[1] = {{\n", VSB_data(p->cname));
212	1217307	Fh(tl, 1, "\t.magic\t\t= VCL_SUB_MAGIC,\n");
213	1217307	Fh(tl, 1, "\t.methods\t= 0x%x,\n", p->okmask);
214	1217307	Fh(tl, 1, "\t.name\t\t= \"%.*s\",\n", PF(p->name));
215	1217307	Fh(tl, 1, "\t.vcl_conf\t= &VCL_conf,\n");
216	2434614	Fh(tl, 1, "\t.func\t\t= %s,\n", VSB_data(p->cname));
217	1217307	Fh(tl, 1, "\t.n\t\t= %d,\n", nsub);
218	1217307	Fh(tl, 1, "\t.nref\t\t= %d,\n", p->sym->nref);
219	1217307	Fh(tl, 1, "\t.called\t\t= %d\n", p->called);
220	1217307	Fh(tl, 1, "\t// calledfrom\t 0x%x\n", p->calledfrom);
221	1217307	Fh(tl, 1, "}};\n");
222
223	1217307	if (dyn) {
224	714	Fc(tl, 1, "\nstatic inline void %s\n", cc_adv);
225	714	Fc(tl, 1, "%s_checked(VRT_CTX)\n{\n", VSB_data(p->cname));
226	714	} else {
227	2433900	Fc(tl, 1, "\nvoid %sv_matchproto_(vcl_func_f)\n", cc_adv);
228	2433186	Fc(tl, 1, "%s(VRT_CTX, enum vcl_func_call_e call,\n",
229	1216593	VSB_data(p->cname));
230	1216593	Fc(tl, 1, " enum vcl_func_fail_e *failp)\n{\n");
231	1216593	Fc(tl, 1, " assert(call == VSUB_STATIC);\n");
232	1216593	Fc(tl, 1, " assert(failp == NULL);\n");
233		}
234
235	1217307	vsbm = VSB_new_auto();
236	1217307	AN(vsbm);
237	1217307	vcc_vcl_met2c(vsbm, mask);
238	1217307	AZ(VSB_finish(vsbm));
239	1217307	Fc(tl, 1, " assert(ctx->method %s (%s));\n", maskcmp, VSB_data(vsbm));
240	1217307	VSB_destroy(&vsbm);
241	1217307	Fc(tl, 1, "%s\n%s}\n", VSB_data(p->prologue), VSB_data(p->body));
242	1217307	VSB_destroy(&p->body);
243	1217307	VSB_destroy(&p->prologue);
244
245	1217307	if (! dyn) {
246	1216593	VSB_destroy(&p->cname);
247	1216593	return;
248		}
249
250		/* wrapper to call the actual (_checked) function */
251	714	Fc(tl, 1, "\nvoid v_matchproto_(vcl_func_f)\n");
252	1428	Fc(tl, 1, "%s(VRT_CTX, enum vcl_func_call_e call,\n",
253	714	VSB_data(p->cname));
254	714	Fc(tl, 1, " enum vcl_func_fail_e *failp)\n{\n");
255	714	Fc(tl, 1, " enum vcl_func_fail_e fail;\n\n");
256	1428	Fc(tl, 1, " fail = VPI_Call_Check(ctx, &VCL_conf, 0x%x, %d);\n",
257	714	mask, nsub);
258	714	Fc(tl, 1, " if (failp)\n");
259	714	Fc(tl, 1, " *failp = fail;\n");
260	714	Fc(tl, 1, " else if (fail == VSUB_E_METHOD)\n");
261	1428	Fc(tl, 1, " VRT_fail(ctx, \"call to \\\"sub %.*s{}\\\""
262	714	" not allowed from here\");\n", PF(p->name));
263	714	Fc(tl, 1, " else if (fail == VSUB_E_RECURSE)\n");
264	1428	Fc(tl, 1, " VRT_fail(ctx, \"Recursive call to "
265	714	"\\\"sub %.*s{}\\\"\");\n", PF(p->name));
266	714	Fc(tl, 1, " else\n");
267	714	Fc(tl, 1, " assert (fail == VSUB_E_OK);\n");
268	714	Fc(tl, 1, " if (fail != VSUB_E_OK \|\| call == VSUB_CHECK)\n");
269	714	Fc(tl, 1, " return;\n");
270	714	Fc(tl, 1, " VPI_Call_Begin(ctx, %d);\n", nsub);
271	714	Fc(tl, 1, " %s_checked(ctx);\n", VSB_data(p->cname));
272	714	Fc(tl, 1, " VPI_Call_End(ctx, %d);\n", nsub);
273	714	Fc(tl, 1, "}\n");
274	714	VSB_destroy(&p->cname);
275	1217307	}
276
277		/--------------------------------------------------------------------/
278
279		struct inifin *
280	473416	New_IniFin(struct vcc *tl)
281		{
282		struct inifin *p;
283
284	473416	ALLOC_OBJ(p, INIFIN_MAGIC);
285	473416	AN(p);
286	473416	p->ini = VSB_new_auto();
287	473416	AN(p->ini);
288	473416	p->fin = VSB_new_auto();
289	473416	AN(p->fin);
290	473416	p->final = VSB_new_auto();
291	473416	AN(p->final);
292	473416	p->event = VSB_new_auto();
293	473416	AN(p->event);
294	473416	p->n = ++tl->ninifin;
295	473416	VTAILQ_INSERT_TAIL(&tl->inifin, p, list);
296	473416	return (p);
297		}
298
299		/*--------------------------------------------------------------------
300		* Printf output to the vsbs, possibly indented
301		*/
302
303		void
304	21717873	Fh(const struct vcc tl, int indent, const char fmt, ...)
305		{
306		va_list ap;
307
308	21717873	if (indent)
309	15852711	VSB_printf(tl->fh, "%.s", tl->hindent, tl->hindent, "");
310	21717873	va_start(ap, fmt);
311	21717873	VSB_vprintf(tl->fh, fmt, ap);
312	21717873	va_end(ap);
313	21717873	}
314
315		void
316	57171583	Fb(const struct vcc tl, int indent, const char fmt, ...)
317		{
318		va_list ap;
319
320	57171583	assert(tl->fb != NULL);
321	57171583	if (indent)
322	50654435	VSB_printf(tl->fb, "%.s", tl->indent, tl->indent, "");
323	57171583	va_start(ap, fmt);
324	57171583	VSB_vprintf(tl->fb, fmt, ap);
325	57171583	va_end(ap);
326	57171583	}
327
328		void
329	44142563	Fc(const struct vcc tl, int indent, const char fmt, ...)
330		{
331		va_list ap;
332
333	44142563	if (indent)
334	8532573	VSB_printf(tl->fc, "%.s", tl->indent, tl->indent, "");
335	44142563	va_start(ap, fmt);
336	44142563	VSB_vprintf(tl->fc, fmt, ap);
337	44142563	va_end(ap);
338	44142563	}
339
340		/--------------------------------------------------------------------/
341
342		void
343	2663137	EncToken(struct vsb sb, const struct token t)
344		{
345
346	2663137	assert(t->tok == CSTR);
347	2663137	VSB_quote(sb, t->dec, -1, VSB_QUOTE_CSTR);
348	2663137	}
349
350		/*--------------------------------------------------------------------
351		* Output the location/profiling table. For each counted token, we
352		* record source+line+charpos for the first character in the token.
353		*/
354
355		static void
356	27636	EmitCoordinates(const struct vcc tl, struct vsb vsb)
357		{
358		struct token *t;
359		unsigned lin, pos;
360		const struct source *sp;
361		const char *p;
362
363	27636	VSB_cat(vsb, "/* ---===### Source Code ###===---*/\n");
364
365	27636	VSB_printf(vsb, "\n#define VGC_NSRCS %u\n", tl->nsources);
366
367	27636	VSB_cat(vsb, "\nstatic const char *srcname[VGC_NSRCS] = {\n");
368	83580	VTAILQ_FOREACH(sp, &tl->sources, list) {
369	55944	VSB_cat(vsb, "\t");
370	55944	VSB_quote(vsb, sp->name, -1, VSB_QUOTE_CSTR);
371	55944	VSB_cat(vsb, ",\n");
372	55944	}
373	27636	VSB_cat(vsb, "};\n");
374
375	27636	VSB_printf(vsb, "\nstatic const char *srcbody[%u] = {\n", tl->nsources);
376	83580	VTAILQ_FOREACH(sp, &tl->sources, list) {
377	55944	VSB_cat(vsb, " /* ");
378	55944	VSB_quote(vsb, sp->name, -1, VSB_QUOTE_CSTR);
379	55944	VSB_cat(vsb, " */\n");
380	55944	VSB_quote_pfx(vsb, "\t", sp->b, sp->e - sp->b, VSB_QUOTE_CSTR);
381	55944	VSB_cat(vsb, ",\n");
382	55944	}
383	27636	VSB_cat(vsb, "};\n\n");
384
385	27636	VSB_cat(vsb, "/* ---===### Location Counters ###===---*/\n");
386
387	27636	VSB_printf(vsb, "\n#define VGC_NREFS %u\n\n", tl->cnt + 1);
388
389	27636	VSB_cat(vsb, "static const struct vpi_ref VGC_ref[VGC_NREFS] = {\n");
390	27636	lin = 1;
391	27636	pos = 0;
392	27636	sp = 0;
393	27636	p = NULL;
394	29253294	VTAILQ_FOREACH(t, &tl->tokens, list) {
395	29225658	if (t->cnt == 0)
396	26779158	continue;
397	2446500	assert(t->src != NULL);
398	2446500	if (t->src != sp) {
399	47040	lin = 1;
400	47040	pos = 0;
401	47040	sp = t->src;
402	47040	p = sp->b;
403	47040	}
404	2446500	assert(sp != NULL);
405	2446500	assert(p != NULL);
406	252706106	for (;p < t->b; p++) {
407	250259606	if (*p == '\n') {
408	10629108	lin++;
409	10629108	pos = 0;
410	250259606	} else if (*p == '\t') {
411	5472747	pos &= ~7;
412	5472747	pos += 8;
413	5472747	} else
414	234157751	pos++;
415
416	250259606	}
417	4893000	VSB_printf(vsb, " [%3u] = { VPI_REF_MAGIC, %u, %8tu, %4u, %3u, ",
418	2446500	t->cnt, sp->idx, t->b - sp->b, lin, pos + 1);
419	2446500	if (t->tok == CSRC)
420	147	VSB_cat(vsb, " \"C{\"},\n");
421		else
422	2446353	VSB_printf(vsb, " \"%.*s\" },\n", PF(t));
423	2446500	}
424	27636	VSB_cat(vsb, "};\n\n");
425	27636	}
426
427		/*--------------------------------------------------------------------
428		* Init/Fini/Event
429		*
430		* We call DISCARD and COLD events in the opposite order of LOAD and
431		* WARM.
432		*/
433
434		static void
435	27636	EmitInitFini(struct vcc *tl)
436		{
437	27636	struct inifin p, q = NULL;
438	27636	unsigned has_event = 0;
439		struct symbol *sy;
440
441	27636	Fh(tl, 0, "\n");
442	27636	Fh(tl, 0, "static unsigned vgc_inistep;\n");
443	27636	Fh(tl, 0, "static unsigned vgc_warmupstep;\n");
444
445		/*
446		* LOAD
447		*/
448	27636	Fc(tl, 0, "\nstatic int\nVGC_Load(VRT_CTX)\n{\n\n");
449	27636	Fc(tl, 0, "\tvgc_inistep = 0;\n");
450	27636	Fc(tl, 0, "\tsize_t ndirector = %dUL;\n", tl->ndirector);
451	27636	Fc(tl, 0, "\n");
452	278271	VTAILQ_FOREACH(p, &tl->inifin, list) {
453	250635	AZ(VSB_finish(p->ini));
454	250635	assert(p->n > 0);
455	250635	if (VSB_len(p->ini))
456	246078	Fc(tl, 0, "\t/* %u */\n%s\n", p->n, VSB_data(p->ini));
457	250635	if (p->ignore_errors == 0) {
458	222894	Fc(tl, 0, "\tif (ctx->vpi->handling == VCL_RET_FAIL)\n");
459	222894	Fc(tl, 0, "\t\treturn(1);\n");
460	222894	}
461	250635	Fc(tl, 0, "\tvgc_inistep = %u;\n\n", p->n);
462	250635	VSB_destroy(&p->ini);
463
464	250635	AZ(VSB_finish(p->event));
465	250635	if (VSB_len(p->event))
466	4389	has_event = 1;
467	250635	}
468
469		/* Handle failures from vcl_init */
470	27636	Fc(tl, 0, "\n");
471	27636	Fc(tl, 0, "\tif (ctx->vpi->handling != VCL_RET_OK)\n");
472	27636	Fc(tl, 0, "\t\treturn(1);\n");
473	27636	Fc(tl, 0, "\tctx->vpi->handling = 0;\n");
474
475	31626	VTAILQ_FOREACH(sy, &tl->sym_objects, sideways) {
476	3990	Fc(tl, 0, "\tif (!%s) {\n", sy->rname);
477	7980	Fc(tl, 0, "\t\tVRT_fail(ctx, "
478	3990	"\"Object %s not initialized\");\n" , sy->name);
479	3990	Fc(tl, 0, "\t\treturn(1);\n");
480	3990	Fc(tl, 0, "\t}\n");
481	3990	}
482
483	27636	Fc(tl, 0, "\treturn(0);\n");
484	27636	Fc(tl, 0, "}\n");
485
486		/*
487		* DISCARD
488		*/
489	27636	Fc(tl, 0, "\nstatic int\nVGC_Discard(VRT_CTX)\n{\n\n");
490
491	27636	Fc(tl, 0, "\tswitch (vgc_inistep) {\n");
492	278271	VTAILQ_FOREACH_REVERSE(p, &tl->inifin, inifinhead, list) {
493	250635	AZ(VSB_finish(p->fin));
494	250635	if (q)
495	222999	assert(q->n > p->n);
496	250635	q = p;
497	250635	Fc(tl, 0, "\t\tcase %u:\n", p->n);
498	250635	if (VSB_len(p->fin))
499	250488	Fc(tl, 0, "\t%s\n", VSB_data(p->fin));