女同性恋cbcb


/*-
 * Copyright (c) 2010 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.
 */
/*lint -save -esym(759, SYMTAB_NOERR) -esym(765, SYMTAB_NOERR)*/

#include "config.h"

#include <ctype.h>
#include <stdlib.h>
#include <string.h>

#include "vcc_compile.h"

#include "vct.h"

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

#define VCC_KIND(U,l) const struct kind SYM_##U[1] = {{ KIND_MAGIC, #l}};
#include "tbl/symbol_kind.h"

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

struct vcc_namespace {
        unsigned                magic;
#define VCC_NAMESPACE_MAGIC     0x27b842f4
        const char              *name;
        enum vcc_namespace_e    id;
};

#define VCC_NAMESPACE(U, l)                             \
        static const struct vcc_namespace sym_##l = {   \
                VCC_NAMESPACE_MAGIC,                    \
                #l,                                     \
                VCC_NAMESPACE_##U                       \
        };                                              \
        vcc_ns_t SYM_##U = &sym_##l;
#include "vcc_namespace.h"

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

struct symtab {
        unsigned                        magic;
#define SYMTAB_MAGIC                    0x084d9c8a
        unsigned                        nlen;
        const char                      *name;
        const struct symtab             *parent;
        VTAILQ_ENTRY(symtab)            list;
        VTAILQ_HEAD(,symtab)            children;
        VTAILQ_HEAD(,symbol)            symbols;
};

vcc_kind_t
VCC_HandleKind(vcc_type_t fmt)
{
        if (fmt == ACL)         return (SYM_ACL);
        if (fmt == BACKEND)     return (SYM_BACKEND);
        if (fmt == PROBE)       return (SYM_PROBE);
        if (fmt == STEVEDORE)   return (SYM_STEVEDORE);
        if (fmt == SUB)         return (SYM_SUB);
        if (fmt == INSTANCE)    return (SYM_INSTANCE);
        AZ(fmt->global_pfx);
        return (SYM_NONE);
}

void
VCC_PrintCName(struct vsb *vsb, const char *b, const char *e)
{

        AN(vsb);
        AN(b);

        if (e == NULL)
                e = strchr(b, '\0');
        assert(b < e);

        for (; b < e; b++)
                if (vct_isalnum(*b))
                        VSB_putc(vsb, *b);
                else
                        VSB_printf(vsb, "_%02x_", *b);
}

static void
vcc_symtabname(struct vsb *vsb, const struct symtab *st)
{
        if (st->parent != NULL && st->parent->parent != NULL) {
                vcc_symtabname(vsb, st->parent);
                VSB_putc(vsb, '.');
        }
        VSB_cat(vsb, st->name);
}

void
VCC_SymName(struct vsb *vsb, const struct symbol *sym)
{
        AN(vsb);
        CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
        CHECK_OBJ_NOTNULL(sym->symtab, SYMTAB_MAGIC);
        vcc_symtabname(vsb, sym->symtab);
}

static struct symtab *
vcc_symtab_new(const char *name)
{
        struct symtab *st;

        ALLOC_OBJ(st, SYMTAB_MAGIC);
        AN(st);
        st->name = name;
        st->nlen = strlen(st->name);
        VTAILQ_INIT(&st->children);
        VTAILQ_INIT(&st->symbols);
        return (st);
}

static struct symtab *
vcc_symtab_str(struct symtab *st, const char *b, const char *e, unsigned tok)
{
        struct symtab *st2, *st3;
        size_t l;
        int i;
        const char *q;

        assert(tok == ID || tok == CSTR);
        if (e == NULL)
                e = strchr(b, '\0');
        q = e;

        while (b < e) {
                if (tok == ID) {
                        for (q = b; q < e && *q != '.'; q++)
                                continue;
                }
                l = pdiff(b, q);
                VTAILQ_FOREACH(st2, &st->children, list) {
                        i = strncasecmp(st2->name, b, l);
                        if (i < 0)
                                continue;
                        if (i == 0 && l == st2->nlen)
                                break;
                        st3 = vcc_symtab_new(vcc_Dup_be(b, q));
                        st3->parent = st;
                        VTAILQ_INSERT_BEFORE(st2, st3, list);
                        st2 = st3;
                        break;
                }
                if (st2 == NULL) {
                        st2 = vcc_symtab_new(vcc_Dup_be(b, q));
                        st2->parent = st;
                        VTAILQ_INSERT_TAIL(&st->children, st2, list);
                }
                st = st2;
                b = q + 1;
        }
        return (st);
}

static struct symbol *
vcc_new_symbol(struct vcc *tl, struct symtab *st,
    vcc_kind_t kind, int vlo, int vhi)
{
        struct symbol *sym;

        sym = TlAlloc(tl, sizeof *sym);
        INIT_OBJ(sym, SYMBOL_MAGIC);
        AN(sym);
        sym->name = st->name;
        sym->symtab = st;
        sym->kind = kind;
        sym->type = VOID;
        sym->lorev = vlo;
        sym->hirev = vhi;
        VTAILQ_INSERT_TAIL(&st->symbols, sym, list);
        return (sym);
}

static struct symbol *
vcc_sym_in_tab(struct vcc *tl, struct symtab *st,
    vcc_kind_t kind, int vlo, int vhi)
{
        const struct symtab *pst;
        struct symbol *sym, *psym;

        VTAILQ_FOREACH(sym, &st->symbols, list) {
                if (sym->lorev > vhi || sym->hirev < vlo)
                        continue;
                if (kind == SYM_NONE && kind == sym->kind &&
                    sym->wildcard == NULL)
                        continue;
                if (tl->syntax < VCL_41 && strcmp(sym->name, "default") &&
                     kind != SYM_NONE && kind != sym->kind &&
                     sym->wildcard == NULL)
                        continue;
                return (sym);
        }
        pst = st->parent;
        if (pst == NULL)
                return (sym);
        psym = VTAILQ_FIRST(&pst->symbols);
        if (psym == NULL)
                return (sym);
        if (psym->wildcard == NULL)
                return (sym);

        sym = vcc_new_symbol(tl, st, kind, vlo, vhi);
        psym->wildcard(tl, psym, sym);
        if (tl->err)
                return (NULL);
        return (sym);
}


const struct symxref XREF_NONE[1] = {{"xref_none"}};
const struct symxref XREF_DEF[1] = {{"xref_def"}};
const struct symxref XREF_REF[1] = {{"xref_ref"}};

const struct symmode SYMTAB_NOERR[1] = {{
        .name = "sym_noerror",
        .noerr = 1
}};

const struct symmode SYMTAB_CREATE[1] = {{
        .name = "sym_create"
}};

const struct symmode SYMTAB_EXISTING[1] = {{
        .name = "Symbol not found"
}};

const struct symmode SYMTAB_PARTIAL[1] = {{
        .name = "Symbol not found",
        .partial = 1
}};

const struct symmode SYMTAB_PARTIAL_NOERR[1] = {{
        .name = "Symbol not found",
        .partial = 1,
        .noerr = 1
}};

struct symbol *
VCC_SymbolGet(struct vcc *tl, vcc_ns_t ns, vcc_kind_t kind,
    const struct symmode *e, const struct symxref *x)
{
        struct symtab *st, *st2 = NULL;
        struct symbol *sym = NULL, *sym2 = NULL;
        struct token *t0, *tn, *tn1, *tn2 = NULL;

        AN(tl);
        CHECK_OBJ_NOTNULL(ns, VCC_NAMESPACE_MAGIC);
        AN(ns->name);
        CHECK_OBJ_NOTNULL(kind, KIND_MAGIC);
        AN(e);
        AN(x);
        AN(x->name);
        if (tl->syntax >= VCL_41 && e == SYMTAB_CREATE && kind != SYM_SUB &&
            vcc_Has_vcl_prefix(tl->t->b)) {
                VSB_cat(tl->sb, "Symbols named 'vcl_*' are reserved.\nAt:");
                vcc_ErrWhere(tl, tl->t);
                return (NULL);
        }

        st = tl->syms[ns->id];
        t0 = tl->t;
        tn = tl->t;
        assert(tn->tok == ID);
        while (1) {
                assert(tn->tok == ID || tn->tok == CSTR);
                if (tn->tok == CSTR && tl->syntax < VCL_41) {
                        VSB_cat(tl->sb,
                            "Quoted headers are available for VCL >= 4.1.\n"
                            "At:");
                        vcc_ErrWhere(tl, tn);
                        return (NULL);
                }
                if (tn->tok == ID)
                        st = vcc_symtab_str(st, tn->b, tn->e, tn->tok);
                else
                        st = vcc_symtab_str(st, tn->dec, NULL, tn->tok);
                sym2 = vcc_sym_in_tab(tl, st, kind, tl->syntax, tl->syntax);
                if (sym2 != NULL) {
                        sym = sym2;
                        st2 = st;
                        tn2 = tn;
                }
                tn1 = vcc_PeekTokenFrom(tl, tn);
                if (tn1->tok != '.')
                        break;
                tn1 = vcc_PeekTokenFrom(tl, tn1);
                if (tn1->tok == CSTR && (sym == NULL || sym->wildcard == NULL))
                        break;
                if (tn1->tok != CSTR && tn1->tok != ID)
                        break;
                tn = tn1;
        }
        if (sym != NULL && sym->kind == SYM_ALIAS) {
                assert(ns == SYM_MAIN);
                st = vcc_symtab_str(tl->syms[ns->id], sym->eval_priv, NULL, ID);
                AN(st);
                st2 = st;
                sym = vcc_sym_in_tab(tl, st, SYM_NONE, sym->lorev, sym->hirev);
                AN(sym);
        }
        if (sym != NULL && sym->kind == SYM_VMOD && e->partial)
                e = SYMTAB_EXISTING;
        if (sym != NULL && e->partial) {
                st = st2;
                tn = tn2;
        } else if (st != st2) {
                sym = NULL;
        }
        if (tl->err || (sym == NULL && e->noerr))
                return (sym);
        AN(st);
        AN(tn);
        if (sym == NULL && e == SYMTAB_CREATE)
                sym = vcc_new_symbol(tl, st, kind, tl->syntax, tl->syntax);
        tl->t = vcc_PeekTokenFrom(tl, tn);
        if (tl->err)
                return (NULL);
        if (sym == NULL) {
                VSB_printf(tl->sb, "%s: '", e->name);
                vcc_PrintTokens(tl, t0, tl->t);
                VSB_cat(tl->sb, "'");
                sym = vcc_sym_in_tab(tl, st, kind, VCL_LOW, VCL_HIGH);
                if (sym != NULL && sym->kind != SYM_OBJECT &&
                    sym->kind != SYM_INSTANCE) { /* XXX: too specific */
                        VSB_cat(tl->sb, " (Only available when");
                        if (sym->lorev >= VCL_LOW)
                                VSB_printf(tl->sb, " %.1f <=", .1 * sym->lorev);
                        VSB_cat(tl->sb, " VCL syntax");
                        if (sym->hirev <= VCL_HIGH)
                                VSB_printf(tl->sb, " <= %.1f", .1 * sym->hirev);
                        VSB_cat(tl->sb, ")");
                }
                VSB_cat(tl->sb, "\nAt: ");
                vcc_ErrWhere2(tl, t0, tl->t);
                return (NULL);
        }
        if (kind != SYM_NONE && kind != sym->kind && sym->type != DEFAULT) {
                VSB_cat(tl->sb, "Symbol '");
                vcc_PrintTokens(tl, t0, tl->t);
                VSB_printf(tl->sb, "' has wrong type (%s), expected %s:",
                    sym->kind->name, kind->name);
                VSB_cat(tl->sb, "\nAt: ");
                vcc_ErrWhere2(tl, t0, tl->t);
                if (sym->def_b != NULL) {
                        VSB_cat(tl->sb, "Symbol was defined here: ");
                        vcc_ErrWhere(tl, sym->def_b);
                } else if (sym->ref_b != NULL) {
                        VSB_cat(tl->sb, "Symbol was declared here: ");
                        vcc_ErrWhere(tl, sym->ref_b);
                } else {
                        VSB_cat(tl->sb, "Symbol was builtin\n");
                }
                return (NULL);
        }
        if (x == XREF_DEF) {
                if (sym->def_b == NULL)
                        sym->def_b = t0;
                sym->ndef++;
        } else if (x == XREF_REF) {
                if (sym->ref_b == NULL)
                        sym->ref_b = t0;
                sym->nref++;
        } else {
                assert (x == XREF_NONE);
        }
        return (sym);
}

static struct symbol *
vcc_TypeSymbol(struct vcc *tl, vcc_ns_t ns, vcc_kind_t kind, vcc_type_t type)
{
        struct token t[1], *t0;
        struct symbol *sym;
        struct vsb *buf;

        buf = VSB_new_auto();
        AN(buf);
        VSB_printf(buf, "%s.%.*s", type->name, PF(tl->t));
        AZ(VSB_finish(buf));

        /* NB: we create a fake token but errors are handled by the caller. */
        memcpy(t, tl->t, sizeof *t);
        t->b = VSB_data(buf);
        t->e = t->b + VSB_len(buf);

        t0 = tl->t;
        tl->t = t;
        sym = VCC_SymbolGet(tl, ns, kind, SYMTAB_NOERR, XREF_NONE);
        tl->t = t0;
        VSB_destroy(&buf);

        return (sym);
}

struct symbol *
VCC_TypeSymbol(struct vcc *tl, vcc_kind_t kind, vcc_type_t type)
{

        if (strchr(type->name, '.') == NULL)
                return (vcc_TypeSymbol(tl, SYM_TYPE, kind, type));

        /* NB: type imported from a VMOD */
        return (vcc_TypeSymbol(tl, SYM_MAIN, kind, type));
}

struct symbol *
VCC_MkSym(struct vcc *tl, const char *b, vcc_ns_t ns, vcc_kind_t kind,
    int vlo, int vhi)
{
        struct symtab *st;
        struct symbol *sym;
        const struct symbol *parent;

        AN(tl);
        AN(b);
        CHECK_OBJ_NOTNULL(ns, VCC_NAMESPACE_MAGIC);
        CHECK_OBJ_NOTNULL(kind, KIND_MAGIC);
        assert(vlo <= vhi);

        if (tl->syms[ns->id] == NULL)
                tl->syms[ns->id] = vcc_symtab_new("");
        st = vcc_symtab_str(tl->syms[ns->id], b, NULL, ID);
        AN(st);
        sym = vcc_sym_in_tab(tl, st, kind, vlo, vhi);
        if (sym != NULL) {
                assert(sym->kind == SYM_VAR);
                parent = sym->eval_priv;
                AN(parent);
                AN(parent->wildcard);
                assert(sym->type == parent->type);
                return (sym);
        }
        AZ(sym);
        sym = vcc_new_symbol(tl, st, kind, vlo, vhi);
        AN(sym);
        sym->noref = 1;
        return (sym);
}

struct symbol *
VCC_MkSymAlias(struct vcc *tl, const char *alias, const char *name)
{
        struct symbol *sym_alias, *sym;
        struct symtab *st;

        AN(tl);
        AN(alias);
        AN(name);

        st = vcc_symtab_str(tl->syms[SYM_MAIN->id], name, NULL, ID);
        AN(st);
        sym = vcc_sym_in_tab(tl, st, SYM_NONE, VCL_LOW, VCL_HIGH);
        AN(sym);
        assert(sym->kind != SYM_ALIAS);
        sym_alias = VCC_MkSym(tl, alias, SYM_MAIN, SYM_ALIAS, sym->lorev,
            sym->hirev);
        AN(sym_alias);
        sym_alias->eval_priv = strdup(name);
        AN(sym_alias->eval_priv);
        return (sym);
}

static void
vcc_walksymbols(struct vcc *tl, const struct symtab *root,
    symwalk_f *func, vcc_kind_t kind)
{
        struct symbol *sym;
        struct symtab *st1, *st2 = NULL;

        VTAILQ_FOREACH(sym, &root->symbols, list) {
                if (kind == SYM_NONE || kind == sym->kind)
                        func(tl, sym);
                ERRCHK(tl);
        }
        VTAILQ_FOREACH(st1, &root->children, list) {
                if (st2 != NULL)
                        assert(strcasecmp(st1->name, st2->name) >= 0);
                st2 = st1;
                vcc_walksymbols(tl, st1, func, kind);
                ERRCHK(tl);
        }
}

void
VCC_WalkSymbols(struct vcc *tl, symwalk_f *func, vcc_ns_t ns, vcc_kind_t kind)
{

        CHECK_OBJ_NOTNULL(ns, VCC_NAMESPACE_MAGIC);
        vcc_walksymbols(tl, tl->syms[ns->id], func, kind);
}

void
VCC_GlobalSymbol(struct symbol *sym, vcc_type_t type)
{
        vcc_kind_t kind;
        struct vsb *vsb;

        CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
        AN(type);
        AN(type->global_pfx);

        kind = VCC_HandleKind(type);

        if (sym->lname != NULL) {
                AN(sym->rname);
                assert(sym->type == type);
                assert(sym->kind == kind);
                return;
        }

        vsb = VSB_new_auto();
        AN(vsb);
        VSB_printf(vsb, "%s_", type->global_pfx);
        VCC_PrintCName(vsb, sym->name, NULL);
        AZ(VSB_finish(vsb));
        sym->lname = strdup(VSB_data(vsb));
        AN(sym->lname);
        if (type == SUB) {
                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 = type;
        sym->kind = kind;
        if (sym->kind != SYM_NONE) {
                AZ(VCT_invalid_name(sym->rname, NULL));
                if (type == SUB)
                        sym->eval = vcc_Eval_Sub;
                else
                        sym->eval = vcc_Eval_Handle;
        } else {
                WRONG("Wrong kind of global symbol");
        }

#define VCL_MET_MAC(l,u,t,b)   sym->r_methods |= VCL_MET_##u;
#include "tbl/vcl_returns.h"
}

struct symbol *
VCC_HandleSymbol(struct vcc *tl, vcc_type_t fmt)
{
        struct symbol *sym;
        vcc_kind_t kind;
        struct token *t;
        const char *p;

        if (vcc_IdIs(tl->t, "default") && fmt->default_sym != NULL) {
                vcc_NextToken(tl);
                return (fmt->default_sym);
        }

        kind = VCC_HandleKind(fmt);
        assert(kind != SYM_NONE);

        t = tl->t;
        sym = VCC_SymbolGet(tl, SYM_MAIN, SYM_NONE, SYMTAB_NOERR, XREF_NONE);
        if (sym != NULL && sym->def_b != NULL && kind == sym->kind) {
                p = sym->kind->name;
                VSB_printf(tl->sb, "%c%s '%.*s' redefined.\n",
                    toupper(*p), p + 1, PF(t));
                vcc_ErrWhere(tl, t);
                VSB_cat(tl->sb, "First definition:\n");
                AN(sym->def_b);
                vcc_ErrWhere(tl, sym->def_b);
                return (sym);
        } else if (sym != NULL && sym->def_b != NULL) {
                VSB_printf(tl->sb, "Name '%.*s' already defined.\n", PF(t));
                vcc_ErrWhere(tl, t);
                VSB_cat(tl->sb, "First definition:\n");
                AN(sym->def_b);
                vcc_ErrWhere(tl, sym->def_b);
                return (sym);
        } else if (sym != NULL && sym->kind != kind) {
                VSB_printf(tl->sb,
                    "Name %.*s must have type '%s'.\n",
                    PF(t), sym->kind->name);
                vcc_ErrWhere(tl, t);
                return (sym);
        }
        if (sym == NULL)
                sym = VCC_SymbolGet(tl, SYM_MAIN, kind, SYMTAB_CREATE,
                    XREF_NONE);
        if (sym == NULL)
                return (NULL);
        AN(sym);
        AZ(sym->ndef);
        VCC_GlobalSymbol(sym, fmt);
        sym->ndef = 1;
        if (sym->def_b == NULL)
                sym->def_b = t;
        return (sym);
}
/*lint -restore */

		varnish-cache/lib/libvcc/vcc_symb.c
0		/*-
1		* Copyright (c) 2010 Varnish Software AS
2		* All rights reserved.
3		*
4		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
5		*
6		* SPDX-License-Identifier: BSD-2-Clause
7		*
8		* Redistribution and use in source and binary forms, with or without
9		* modification, are permitted provided that the following conditions
10		* are met:
11		* 1. Redistributions of source code must retain the above copyright
12		* notice, this list of conditions and the following disclaimer.
13		* 2. Redistributions in binary form must reproduce the above copyright
14		* notice, this list of conditions and the following disclaimer in the
15		* documentation and/or other materials provided with the distribution.
16		*
17		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27		* SUCH DAMAGE.
28		*/
29		/lint -save -esym(759, SYMTAB_NOERR) -esym(765, SYMTAB_NOERR)/
30
31		#include "config.h"
32
33		#include <ctype.h>
34		#include <stdlib.h>
35		#include <string.h>
36
37		#include "vcc_compile.h"
38
39		#include "vct.h"
40
41		/--------------------------------------------------------------------/
42
43		#define VCC_KIND(U,l) const struct kind SYM_##U[1] = {{ KIND_MAGIC, #l}};
44		#include "tbl/symbol_kind.h"
45
46		/--------------------------------------------------------------------/
47
48		struct vcc_namespace {
49		unsigned magic;
50		#define VCC_NAMESPACE_MAGIC 0x27b842f4
51		const char *name;
52		enum vcc_namespace_e id;
53		};
54
55		#define VCC_NAMESPACE(U, l) \
56		static const struct vcc_namespace sym_##l = { \
57		VCC_NAMESPACE_MAGIC, \
58		#l, \
59		VCC_NAMESPACE_##U \
60		}; \
61		vcc_ns_t SYM_##U = &sym_##l;
62		#include "vcc_namespace.h"
63
64		/--------------------------------------------------------------------/
65
66		struct symtab {
67		unsigned magic;
68		#define SYMTAB_MAGIC 0x084d9c8a
69		unsigned nlen;
70		const char *name;
71		const struct symtab *parent;
72		VTAILQ_ENTRY(symtab) list;
73		VTAILQ_HEAD(,symtab) children;
74		VTAILQ_HEAD(,symbol) symbols;
75		};
76
77		vcc_kind_t
78	396478	VCC_HandleKind(vcc_type_t fmt)
79		{
80	396478	if (fmt == ACL) return (SYM_ACL);
81	396300	if (fmt == BACKEND) return (SYM_BACKEND);
82	389896	if (fmt == PROBE) return (SYM_PROBE);
83	389850	if (fmt == STEVEDORE) return (SYM_STEVEDORE);
84	389850	if (fmt == SUB) return (SYM_SUB);
85	820	if (fmt == INSTANCE) return (SYM_INSTANCE);
86	0	AZ(fmt->global_pfx);
87	0	return (SYM_NONE);
88	396478	}
89
90		void
91	291108	VCC_PrintCName(struct vsb vsb, const char b, const char *e)
92		{
93
94	291108	AN(vsb);
95	291108	AN(b);
96
97	291108	if (e == NULL)
98	291108	e = strchr(b, '\0');
99	291108	assert(b < e);
100
101	4727842	for (; b < e; b++)
102	8873468	if (vct_isalnum(*b))
103	3998504	VSB_putc(vsb, *b);
104		else
105	438230	VSB_printf(vsb, "_%02x_", *b);
106	291108	}
107
108		static void
109	1272026	vcc_symtabname(struct vsb vsb, const struct symtab st)
110		{
111	1272026	if (st->parent != NULL && st->parent->parent != NULL) {
112	567016	vcc_symtabname(vsb, st->parent);
113	567016	VSB_putc(vsb, '.');
114	567016	}
115	1272026	VSB_cat(vsb, st->name);
116	1272026	}
117
118		void
119	705010	VCC_SymName(struct vsb vsb, const struct symbol sym)
120		{
121	705010	AN(vsb);
122	705010	CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
123	705010	CHECK_OBJ_NOTNULL(sym->symtab, SYMTAB_MAGIC);
124	705010	vcc_symtabname(vsb, sym->symtab);
125	705010	}
126
127		static struct symtab *
128	1592650	vcc_symtab_new(const char *name)
129		{
130		struct symtab *st;
131
132	1592650	ALLOC_OBJ(st, SYMTAB_MAGIC);
133	1592650	AN(st);
134	1592650	st->name = name;
135	1592650	st->nlen = strlen(st->name);
136	1592650	VTAILQ_INIT(&st->children);
137	1592650	VTAILQ_INIT(&st->symbols);
138	1592650	return (st);
139		}
140
141		static struct symtab *
142	3329526	vcc_symtab_str(struct symtab st, const char b, const char *e, unsigned tok)
143		{
144		struct symtab st2, st3;
145		size_t l;
146		int i;
147		const char *q;
148
149	3329526	assert(tok == ID \|\| tok == CSTR);
150	3329526	if (e == NULL)
151	1297204	e = strchr(b, '\0');
152	3329526	q = e;
153
154	7771066	while (b < e) {
155	4441540	if (tok == ID) {
156	38442090	for (q = b; q < e && *q != '.'; q++)
157	34000570	continue;
158	4441520	}
159	4441540	l = pdiff(b, q);
160	74756382	VTAILQ_FOREACH(st2, &st->children, list) {
161	73677992	i = strncasecmp(st2->name, b, l);
162	73677992	if (i < 0)
163	70314842	continue;
164	3363150	if (i == 0 && l == st2->nlen)
165	2861232	break;
166	501918	st3 = vcc_symtab_new(vcc_Dup_be(b, q));
167	501918	st3->parent = st;
168	501918	VTAILQ_INSERT_BEFORE(st2, st3, list);
169	501918	st2 = st3;
170	501918	break;
171		}
172	4441540	if (st2 == NULL) {
173	1078390	st2 = vcc_symtab_new(vcc_Dup_be(b, q));
174	1078390	st2->parent = st;
175	1078390	VTAILQ_INSERT_TAIL(&st->children, st2, list);
176	1078390	}
177	4441540	st = st2;
178	4441540	b = q + 1;
179		}
180	3329526	return (st);
181		}
182
183		static struct symbol *
184	1539824	vcc_new_symbol(struct vcc tl, struct symtab st,
185		vcc_kind_t kind, int vlo, int vhi)
186		{
187		struct symbol *sym;
188
189	1539824	sym = TlAlloc(tl, sizeof *sym);
190	1539824	INIT_OBJ(sym, SYMBOL_MAGIC);
191	1539824	AN(sym);
192	1539824	sym->name = st->name;
193	1539824	sym->symtab = st;
194	1539824	sym->kind = kind;
195	1539824	sym->type = VOID;
196	1539824	sym->lorev = vlo;
197	1539824	sym->hirev = vhi;
198	1539824	VTAILQ_INSERT_TAIL(&st->symbols, sym, list);
199	1539824	return (sym);
200		}
201
202		static struct symbol *
203	3329578	vcc_sym_in_tab(struct vcc tl, struct symtab st,
204		vcc_kind_t kind, int vlo, int vhi)
205		{
206		const struct symtab *pst;
207		struct symbol sym, psym;
208
209	3356854	VTAILQ_FOREACH(sym, &st->symbols, list) {
210	1633496	if (sym->lorev > vhi \|\| sym->hirev < vlo)
211	27260	continue;
212	1606236	if (kind == SYM_NONE && kind == sym->kind &&
213	81918	sym->wildcard == NULL)
214	0	continue;
215	1628554	if (tl->syntax < VCL_41 && strcmp(sym->name, "default") &&
216	915624	kind != SYM_NONE && kind != sym->kind &&
217	22318	sym->wildcard == NULL)
218	16	continue;
219	1606220	return (sym);
220		}
221	1723358	pst = st->parent;
222	1723358	if (pst == NULL)
223	0	return (sym);
224	1723358	psym = VTAILQ_FIRST(&pst->symbols);
225	1723358	if (psym == NULL)
226	1007620	return (sym);
227	715738	if (psym->wildcard == NULL)
228	576708	return (sym);
229
230	139030	sym = vcc_new_symbol(tl, st, kind, vlo, vhi);
231	139030	psym->wildcard(tl, psym, sym);
232	139030	if (tl->err)
233	4	return (NULL);
234	139026	return (sym);
235	3329578	}
236
237
238		const struct symxref XREF_NONE[1] = {{"xref_none"}};
239		const struct symxref XREF_DEF[1] = {{"xref_def"}};
240		const struct symxref XREF_REF[1] = {{"xref_ref"}};
241
242		const struct symmode SYMTAB_NOERR[1] = {{
243		.name = "sym_noerror",
244		.noerr = 1
245		}};
246
247		const struct symmode SYMTAB_CREATE[1] = {{
248		.name = "sym_create"
249		}};
250
251		const struct symmode SYMTAB_EXISTING[1] = {{
252		.name = "Symbol not found"
253		}};
254
255		const struct symmode SYMTAB_PARTIAL[1] = {{
256		.name = "Symbol not found",
257		.partial = 1
258		}};
259
260		const struct symmode SYMTAB_PARTIAL_NOERR[1] = {{
261		.name = "Symbol not found",
262		.partial = 1,
263		.noerr = 1
264		}};
265
266		struct symbol *
267	1542368	VCC_SymbolGet(struct vcc *tl, vcc_ns_t ns, vcc_kind_t kind,
268		const struct symmode e, const struct symxref x)
269		{
270	1542368	struct symtab st, st2 = NULL;
271	1542368	struct symbol sym = NULL, sym2 = NULL;
272	1542368	struct token t0, tn, tn1, tn2 = NULL;
273
274	1542368	AN(tl);
275	1542368	CHECK_OBJ_NOTNULL(ns, VCC_NAMESPACE_MAGIC);
276	1542368	AN(ns->name);
277	1542368	CHECK_OBJ_NOTNULL(kind, KIND_MAGIC);
278	1542368	AN(e);
279	1542368	AN(x);
280	1542368	AN(x->name);
281	1542368	if (tl->syntax >= VCL_41 && e == SYMTAB_CREATE && kind != SYM_SUB &&
282	4812	vcc_Has_vcl_prefix(tl->t->b)) {
283	4	VSB_cat(tl->sb, "Symbols named 'vcl_*' are reserved.\nAt:");
284	4	vcc_ErrWhere(tl, tl->t);
285	4	return (NULL);
286		}
287
288	1542364	st = tl->syms[ns->id];
289	1542364	t0 = tl->t;
290	1542364	tn = tl->t;
291	1542364	assert(tn->tok == ID);
292	2032344	while (1) {
293	2032344	assert(tn->tok == ID \|\| tn->tok == CSTR);
294	2032344	if (tn->tok == CSTR && tl->syntax < VCL_41) {
295	2	VSB_cat(tl->sb,
296		"Quoted headers are available for VCL >= 4.1.\n"
297		"At:");
298	2	vcc_ErrWhere(tl, tn);
299	2	return (NULL);
300		}
301	2032342	if (tn->tok == ID)
302	2032322	st = vcc_symtab_str(st, tn->b, tn->e, tn->tok);
303		else
304	20	st = vcc_symtab_str(st, tn->dec, NULL, tn->tok);
305	2032342	sym2 = vcc_sym_in_tab(tl, st, kind, tl->syntax, tl->syntax);
306	2032342	if (sym2 != NULL) {
307	1695614	sym = sym2;
308	1695614	st2 = st;
309	1695614	tn2 = tn;
310	1695614	}
311	2032342	tn1 = vcc_PeekTokenFrom(tl, tn);
312	2032342	if (tn1->tok != '.')
313	1542358	break;
314	489984	tn1 = vcc_PeekTokenFrom(tl, tn1);
315	489984	if (tn1->tok == CSTR && (sym == NULL \|\| sym->wildcard == NULL))
316	2	break;
317	489982	if (tn1->tok != CSTR && tn1->tok != ID)
318	2	break;
319	489980	tn = tn1;
320		}
321	1542362	if (sym != NULL && sym->kind == SYM_ALIAS) {
322	2	assert(ns == SYM_MAIN);
323	2	st = vcc_symtab_str(tl->syms[ns->id], sym->eval_priv, NULL, ID);
324	2	AN(st);
325	2	st2 = st;
326	2	sym = vcc_sym_in_tab(tl, st, SYM_NONE, sym->lorev, sym->hirev);
327	2	AN(sym);
328	2	}
329	1542362	if (sym != NULL && sym->kind == SYM_VMOD && e->partial)
330	2	e = SYMTAB_EXISTING;
331	1542362	if (sym != NULL && e->partial) {
332	807738	st = st2;
333	807738	tn = tn2;
334	1542362	} else if (st != st2) {
335	305338	sym = NULL;
336	305338	}
337	1542362	if (tl->err \|\| (sym == NULL && e->noerr))
338	152064	return (sym);
339	1390298	AN(st);
340	1390298	AN(tn);
341	1390298	if (sym == NULL && e == SYMTAB_CREATE)
342	153222	sym = vcc_new_symbol(tl, st, kind, tl->syntax, tl->syntax);
343	1390298	tl->t = vcc_PeekTokenFrom(tl, tn);
344	1390298	if (tl->err)
345	0	return (NULL);
346	1390298	if (sym == NULL) {
347	52	VSB_printf(tl->sb, "%s: '", e->name);
348	52	vcc_PrintTokens(tl, t0, tl->t);
349	52	VSB_cat(tl->sb, "'");
350	52	sym = vcc_sym_in_tab(tl, st, kind, VCL_LOW, VCL_HIGH);
351	52	if (sym != NULL && sym->kind != SYM_OBJECT &&
352	20	sym->kind != SYM_INSTANCE) { /* XXX: too specific */
353	20	VSB_cat(tl->sb, " (Only available when");
354	20	if (sym->lorev >= VCL_LOW)
355	16	VSB_printf(tl->sb, " %.1f <=", .1 * sym->lorev);
356	20	VSB_cat(tl->sb, " VCL syntax");
357	20	if (sym->hirev <= VCL_HIGH)
358	4	VSB_printf(tl->sb, " <= %.1f", .1 * sym->hirev);
359	20	VSB_cat(tl->sb, ")");
360	20	}
361	52	VSB_cat(tl->sb, "\nAt: ");
362	52	vcc_ErrWhere2(tl, t0, tl->t);
363	52	return (NULL);
364		}
365	1390246	if (kind != SYM_NONE && kind != sym->kind && sym->type != DEFAULT) {
366	6	VSB_cat(tl->sb, "Symbol '");
367	6	vcc_PrintTokens(tl, t0, tl->t);
368	12	VSB_printf(tl->sb, "' has wrong type (%s), expected %s:",
369	6	sym->kind->name, kind->name);
370	6	VSB_cat(tl->sb, "\nAt: ");
371	6	vcc_ErrWhere2(tl, t0, tl->t);
372	6	if (sym->def_b != NULL) {
373	4	VSB_cat(tl->sb, "Symbol was defined here: ");
374	4	vcc_ErrWhere(tl, sym->def_b);
375	6	} else if (sym->ref_b != NULL) {
376	2	VSB_cat(tl->sb, "Symbol was declared here: ");
377	2	vcc_ErrWhere(tl, sym->ref_b);
378	2	} else {
379	0	VSB_cat(tl->sb, "Symbol was builtin\n");
380		}
381	6	return (NULL);
382		}
383	1390240	if (x == XREF_DEF) {
384	237062	if (sym->def_b == NULL)
385	234018	sym->def_b = t0;
386	237062	sym->ndef++;
387	1390240	} else if (x == XREF_REF) {
388	454866	if (sym->ref_b == NULL)
389	305844	sym->ref_b = t0;
390	454866	sym->nref++;
391	454866	} else {
392	698312	assert (x == XREF_NONE);
393		}
394	1390240	return (sym);
395	1542368	}
396
397		static struct symbol *
398	7290	vcc_TypeSymbol(struct vcc *tl, vcc_ns_t ns, vcc_kind_t kind, vcc_type_t type)
399		{
400		struct token t[1], *t0;
401		struct symbol *sym;
402		struct vsb *buf;
403
404	7290	buf = VSB_new_auto();
405	7290	AN(buf);
406	7290	VSB_printf(buf, "%s.%.*s", type->name, PF(tl->t));
407	7290	AZ(VSB_finish(buf));
408
409		/* NB: we create a fake token but errors are handled by the caller. */
410	7290	memcpy(t, tl->t, sizeof *t);
411	7290	t->b = VSB_data(buf);
412	7290	t->e = t->b + VSB_len(buf);
413
414	7290	t0 = tl->t;
415	7290	tl->t = t;
416	7290	sym = VCC_SymbolGet(tl, ns, kind, SYMTAB_NOERR, XREF_NONE);
417	7290	tl->t = t0;
418	7290	VSB_destroy(&buf);
419
420	7290	return (sym);
421		}
422
423		struct symbol *
424	7290	VCC_TypeSymbol(struct vcc *tl, vcc_kind_t kind, vcc_type_t type)
425		{
426
427	7290	if (strchr(type->name, '.') == NULL)
428	5746	return (vcc_TypeSymbol(tl, SYM_TYPE, kind, type));
429
430		/* NB: type imported from a VMOD */
431	1544	return (vcc_TypeSymbol(tl, SYM_MAIN, kind, type));
432	7290	}
433
434		struct symbol *
435	1296932	VCC_MkSym(struct vcc tl, const char b, vcc_ns_t ns, vcc_kind_t kind,
436		int vlo, int vhi)
437		{
438		struct symtab *st;
439		struct symbol *sym;
440		const struct symbol *parent;
441
442	1296932	AN(tl);
443	1296932	AN(b);
444	1296932	CHECK_OBJ_NOTNULL(ns, VCC_NAMESPACE_MAGIC);
445	1296932	CHECK_OBJ_NOTNULL(kind, KIND_MAGIC);
446	1296932	assert(vlo <= vhi);
447
448	1296932	if (tl->syms[ns->id] == NULL)
449	12342	tl->syms[ns->id] = vcc_symtab_new("");
450	1296932	st = vcc_symtab_str(tl->syms[ns->id], b, NULL, ID);
451	1296932	AN(st);
452	1296932	sym = vcc_sym_in_tab(tl, st, kind, vlo, vhi);
453	1296932	if (sym != NULL) {
454	49360	assert(sym->kind == SYM_VAR);
455	49360	parent = sym->eval_priv;
456	49360	AN(parent);
457	49360	AN(parent->wildcard);
458	49360	assert(sym->type == parent->type);
459	49360	return (sym);
460		}
461	1247572	AZ(sym);
462	1247572	sym = vcc_new_symbol(tl, st, kind, vlo, vhi);
463	1247572	AN(sym);
464	1247572	sym->noref = 1;
465	1247572	return (sym);
466	1296932	}
467
468		struct symbol *
469	250	VCC_MkSymAlias(struct vcc tl, const char alias, const char *name)
470		{
471		struct symbol sym_alias, sym;
472		struct symtab *st;
473
474	250	AN(tl);
475	250	AN(alias);
476	250	AN(name);
477
478	250	st = vcc_symtab_str(tl->syms[SYM_MAIN->id], name, NULL, ID);
479	250	AN(st);
480	250	sym = vcc_sym_in_tab(tl, st, SYM_NONE, VCL_LOW, VCL_HIGH);
481	250	AN(sym);
482	250	assert(sym->kind != SYM_ALIAS);
483	500	sym_alias = VCC_MkSym(tl, alias, SYM_MAIN, SYM_ALIAS, sym->lorev,
484	250	sym->hirev);
485	250	AN(sym_alias);
486	250	sym_alias->eval_priv = strdup(name);
487	250	AN(sym_alias->eval_priv);
488	250	return (sym);
489		}
490
491		static void
492	7705716	vcc_walksymbols(struct vcc tl, const struct symtab root,
493		symwalk_f *func, vcc_kind_t kind)
494		{
495		struct symbol *sym;
496	7705716	struct symtab st1, st2 = NULL;
497
498	15173220	VTAILQ_FOREACH(sym, &root->symbols, list) {
499	7467612	if (kind == SYM_NONE \|\| kind == sym->kind)

Henceforth, whatever our philosopher says about Matter will apply to extension and to extension alone. It cannot be apprehended by sight, nor by hearing, nor by smell, nor by taste, for it is neither colour, nor sound, nor odour, nor juice. Neither can it be touched, for it is not a body, but it becomes corporeal on being blended with sensible qualities. And, in a later essay, he describes it as receiving all things and letting them depart again without retaining the slightest trace of their presence.483 Why then, it may be asked, if Plotinus meant extension, could he not say so at once, and save us all this trouble in hunting out his meaning? There were very good reasons why he should not. In the first place, he wished to express himself, so far as possible, in Aristotelian phraseology, and this was incompatible with the reduction of Matter to extension. In the next place, the idea of an infinite void had been already appropriated by the Epicureans, to whose system he was bitterly opposed. And, finally, the extension of ordinary327 experience had not the absolute generality which was needed in order to bring Matter into relation with that ultimate abstraction whence, like everything else, it has now to be derived. That the millionaire was genuine, “in person and not a caricature,” as Dick put it, was evident. Both the nurse, his relative, and his wife, were chatting with him as Jeff delivered the heavy packed ball made up of the gum. 233 "I guess not," said Landor, tolerantly, as he turned[Pg 106] his horse over to his orderly; "but, anyway," he added to Ellton, "we had a picnic—of a sort." Si, unable to think of anything better, went with him. The train had stopped on a switch, and seemed likely to rust fast to the rails, from the way other trains were going by in both directions. The bridge gang, under charge of a burly, red-faced young Englishman, was in the rear car, with their tools, equipments, bedding and cooking utensils. THE DEACON HAS SOME EXPERIENCES WITH THE QUADRUPED. "You are not within a mile of the truth. I know it. Look here: I believe that is Gen. Rosecrans's own cow. She's gone, and I got an order to look around for her. I've never seen her, but from the description given me I believe that's she. Who brought her here?" "Deacon, these brothers and sisters who have come here with me to-night are, like myself, deeply interested in the moral condition of the army, where we all have sons or kinsmen. Now, can't you sit right there and tell us of your observations and experiences, as a Christian man and father, from day to day, of every day that you were down there? Tell us everything, just as it happened each day, that we may be able to judge for ourselves." HAS AN ENCOUNTER WITH THE PROVOST-MARSHAL. "Wonder which one o' them is the 200th Injianny's?" said Si to Shorty. "And your mother, and Harry?" The daughter must be the girl who was talking to him now. She sat on a little stool by the fire, and had brought out some sewing. "Over at Grandturzel—can't see wot's burning from here. Git buckets and come!" These things, however, gave little concern to the worthy who commanded the Kentish division. Tyler, though an excellent blacksmith, possessed few of the qualities requisite for forming a good general. Provided there was no very sensible diminution in the number of his followers, he cared not a straw for the score or two who, after quarrelling, or perhaps fighting, withdrew in such disgust that they vowed rather to pay the full tax for ever than submit to the insolence of the rebels. One man could fight as well as another, reasoned he; and, provided he was obeyed, what mattered it by whom. Dick went and Tom came—it was sure to be all one in the end. But this burst of indignation soon passed away, and upon the suggestion of the prudent Sir Robert Hailes, he sent an evasive answer, with a command that the Commons should attend him at Windsor on the Sunday following. That it was a stratagem to gain entrance to the Tower, was the opinion of several, but, after much discussion, it was decided that the man should be admitted, and that the monk should be exhibited merely to intimidate the rebels, until the result of this promised communication should be known. HoME 女同性恋cbcb ENTER NUMBET 0017
yodle.com.cn
www.eran0.net.cn
fage4.net.cn
www.zoula5.com.cn
www.beiru4.net.cn
www.lieli6.com.cn
www.caner1.net.cn
www.51moyang.org.cn
aquasil.com.cn
www.05331111.com.cn