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)
500 3399142
                        func(tl, sym);
501 7467612
                ERRCHK(tl);
502 7467504
        }
503 15376070
        VTAILQ_FOREACH(st1, &root->children, list) {
504 7670570
                if (st2 != NULL)
505 7002398
                        assert(strcasecmp(st1->name, st2->name) >= 0);
506 7670570
                st2 = st1;
507 7670570
                vcc_walksymbols(tl, st1, func, kind);
508 7670570
                ERRCHK(tl);
509 7670462
        }
510 7705716
}
511
512
void
513 35146
VCC_WalkSymbols(struct vcc *tl, symwalk_f *func, vcc_ns_t ns, vcc_kind_t kind)
514
{
515
516 35146
        CHECK_OBJ_NOTNULL(ns, VCC_NAMESPACE_MAGIC);
517 35146
        vcc_walksymbols(tl, tl->syms[ns->id], func, kind);
518 35146
}
519
520
void
521 300174
VCC_GlobalSymbol(struct symbol *sym, vcc_type_t type)
522
{
523
        vcc_kind_t kind;
524
        struct vsb *vsb;
525
526 300174
        CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
527 300174
        AN(type);
528 300174
        AN(type->global_pfx);
529
530 300174
        kind = VCC_HandleKind(type);
531
532 300174
        if (sym->lname != NULL) {
533 148150
                AN(sym->rname);
534 148150
                assert(sym->type == type);
535 148150
                assert(sym->kind == kind);
536 148150
                return;
537
        }
538
539 152024
        vsb = VSB_new_auto();
540 152024
        AN(vsb);
541 152024
        VSB_printf(vsb, "%s_", type->global_pfx);
542 152024
        VCC_PrintCName(vsb, sym->name, NULL);
543 152024
        AZ(VSB_finish(vsb));
544 152024
        sym->lname = strdup(VSB_data(vsb));
545 152024
        AN(sym->lname);
546 152024
        if (type == SUB) {
547 148304
                VSB_clear(vsb);
548 148304
                VSB_printf(vsb, "sub_%s", sym->lname);
549 148304
                AZ(VSB_finish(vsb));
550 148304
        }
551 152024
        sym->rname = strdup(VSB_data(vsb));
552 152024
        AN(sym->rname);
553 152024
        VSB_destroy(&vsb);
554
555 152024
        sym->type = type;
556 152024
        sym->kind = kind;
557 152024
        if (sym->kind != SYM_NONE) {
558 152024
                AZ(VCT_invalid_name(sym->rname, NULL));
559 152024
                if (type == SUB)
560 148304
                        sym->eval = vcc_Eval_Sub;
561
                else
562 3720
                        sym->eval = vcc_Eval_Handle;
563 152024
        } else {
564 0
                WRONG("Wrong kind of global symbol");
565
        }
566
567
#define VCL_MET_MAC(l,u,t,b)   sym->r_methods |= VCL_MET_##u;
568
#include "tbl/vcl_returns.h"
569
}
570
571
struct symbol *
572 3894
VCC_HandleSymbol(struct vcc *tl, vcc_type_t fmt)
573
{
574
        struct symbol *sym;
575
        vcc_kind_t kind;
576
        struct token *t;
577
        const char *p;
578
579 3894
        if (vcc_IdIs(tl->t, "default") && fmt->default_sym != NULL) {
580 170
                vcc_NextToken(tl);
581 170
                return (fmt->default_sym);
582
        }
583
584 3724
        kind = VCC_HandleKind(fmt);
585 3724
        assert(kind != SYM_NONE);
586
587 3724
        t = tl->t;
588 3724
        sym = VCC_SymbolGet(tl, SYM_MAIN, SYM_NONE, SYMTAB_NOERR, XREF_NONE);
589 3724
        if (sym != NULL && sym->def_b != NULL && kind == sym->kind) {
590 6
                p = sym->kind->name;
591 12
                VSB_printf(tl->sb, "%c%s '%.*s' redefined.\n",
592 6
                    toupper(*p), p + 1, PF(t));
593 6
                vcc_ErrWhere(tl, t);
594 6
                VSB_cat(tl->sb, "First definition:\n");
595 6
                AN(sym->def_b);
596 6
                vcc_ErrWhere(tl, sym->def_b);
597 6
                return (sym);
598 3718
        } else if (sym != NULL && sym->def_b != NULL) {
599 4
                VSB_printf(tl->sb, "Name '%.*s' already defined.\n", PF(t));
600 4
                vcc_ErrWhere(tl, t);
601 4
                VSB_cat(tl->sb, "First definition:\n");
602 4
                AN(sym->def_b);
603 4
                vcc_ErrWhere(tl, sym->def_b);
604 4
                return (sym);
605 3714
        } else if (sym != NULL && sym->kind != kind) {
606 4
                VSB_printf(tl->sb,
607
                    "Name %.*s must have type '%s'.\n",
608 2
                    PF(t), sym->kind->name);
609 2
                vcc_ErrWhere(tl, t);
610 2
                return (sym);
611
        }
612 3712
        if (sym == NULL)
613 3708
                sym = VCC_SymbolGet(tl, SYM_MAIN, kind, SYMTAB_CREATE,
614
                    XREF_NONE);
615 3712
        if (sym == NULL)
616 0
                return (NULL);
617 3712
        AN(sym);
618 3712
        AZ(sym->ndef);
619 3712
        VCC_GlobalSymbol(sym, fmt);
620 3712
        sym->ndef = 1;
621 3712
        if (sym->def_b == NULL)
622 3712
                sym->def_b = t;
623 3712
        return (sym);
624 3894
}
625
/*lint -restore */