Code Coverage: vinyl-cache/lib/libvcc/vcc_symb.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
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
VCC_HandleKind(vcc_type_t fmt)
79 228958
{
80 228958
        if (fmt == ACL)         return (SYM_ACL);
81 228853
        if (fmt == BACKEND)     return (SYM_BACKEND);
82 225485
        if (fmt == PROBE)       return (SYM_PROBE);
83 225450
        if (fmt == STEVEDORE)   return (SYM_STEVEDORE);
84 225450
        if (fmt == SUB)         return (SYM_SUB);
85 410
        if (fmt == INSTANCE)    return (SYM_INSTANCE);
86 0
        AZ(fmt->global_pfx);
87 0
        return (SYM_NONE);
88 0
}
89
90
void
91
VCC_PrintCName(struct vsb *vsb, const char *b, const char *e)
92 166852
{
93
94 166852
        AN(vsb);
95 166852
        AN(b);
96
97 166852
        if (e == NULL)
98 166852
                e = strchr(b, '\0');
99 166852
        assert(b < e);
100
101 2664824
        for (; b < e; b++)
102 2497972
                if (vct_isalnum(*b))
103 2246799
                        VSB_putc(vsb, *b);
104 251173
                else
105 251173
                        VSB_printf(vsb, "_%02x_", *b);
106 166852
}
107
108
static void
109
vcc_symtabname(struct vsb *vsb, const struct symtab *st)
110 720839
{
111 720839
        if (st->parent != NULL && st->parent->parent != NULL) {
112 321443
                vcc_symtabname(vsb, st->parent);
113 321443
                VSB_putc(vsb, '.');
114 321443
        }
115 720839
        VSB_cat(vsb, st->name);
116 720839
}
117
118
void
119
VCC_SymName(struct vsb *vsb, const struct symbol *sym)
120 399396
{
121 399396
        AN(vsb);
122 399396
        CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
123 399396
        CHECK_OBJ_NOTNULL(sym->symtab, SYMTAB_MAGIC);
124 399396
        vcc_symtabname(vsb, sym->symtab);
125 399396
}
126
127
static struct symtab *
128
vcc_symtab_new(const char *name)
129 902055
{
130 902055
        struct symtab *st;
131
132 902055
        ALLOC_OBJ(st, SYMTAB_MAGIC);
133 902055
        AN(st);
134 902055
        st->name = name;
135 902055
        st->nlen = vstrlen(st->name);
136 902055
        VTAILQ_INIT(&st->children);
137 902055
        VTAILQ_INIT(&st->symbols);
138 902055
        return (st);
139 902055
}
140
141
static struct symtab *
142
vcc_symtab_str(struct symtab *st, const char *b, const char *e, unsigned tok)
143 1935433
{
144 1935433
        struct symtab *st2, *st3;
145 1935433
        size_t l;
146 1935433
        int i;
147 1935433
        const char *q;
148
149 1935433
        assert(tok == ID || tok == CSTR);
150 1935433
        if (e == NULL)
151 729645
                e = strchr(b, '\0');
152 1935433
        q = e;
153
154 4501702
        while (b < e) {
155 2566269
                if (tok == ID) {
156 22123045
                        for (q = b; q < e && *q != '.'; q++)
157 19556806
                                continue;
158 2566239
                }
159 2566269
                l = pdiff(b, q);
160 44387269
                VTAILQ_FOREACH(st2, &st->children, list) {
161 44387269
                        i = strncasecmp(st2->name, b, l);
162 44387269
                        if (i < 0)
163 42427642
                                continue;
164 1959627
                        if (i == 0 && l == st2->nlen)
165 1670781
                                break;
166 288846
                        st3 = vcc_symtab_new(vcc_Dup_be(b, q));
167 288846
                        st3->parent = st;
168 288846
                        VTAILQ_INSERT_BEFORE(st2, st3, list);
169 288846
                        st2 = st3;
170 288846
                        break;
171 1959627
                }
172 2566269
                if (st2 == NULL) {
173 606642
                        st2 = vcc_symtab_new(vcc_Dup_be(b, q));
174 606642
                        st2->parent = st;
175 606642
                        VTAILQ_INSERT_TAIL(&st->children, st2, list);
176 606642
                }
177 2566269
                st = st2;
178 2566269
                b = q + 1;
179 2566269
        }
180 1935433
        return (st);
181 1935433
}
182
183
static struct symbol *
184
vcc_new_symbol(struct vcc *tl, struct symtab *st,
185
    vcc_kind_t kind, int vlo, int vhi)
186 870678
{
187 870678
        struct symbol *sym;
188
189 870678
        sym = TlAlloc(tl, sizeof *sym);
190 870678
        INIT_OBJ(sym, SYMBOL_MAGIC);
191 870678
        AN(sym);
192 870678
        sym->name = st->name;
193 870678
        sym->symtab = st;
194 870678
        sym->kind = kind;
195 870678
        sym->type = VOID;
196 870678
        sym->lorev = vlo;
197 870678
        sym->hirev = vhi;
198 870678
        VTAILQ_INSERT_TAIL(&st->symbols, sym, list);
199 870678
        return (sym);
200 870678
}
201
202
static struct symbol *
203
vcc_sym_in_tab(struct vcc *tl, struct symtab *st,
204
    vcc_kind_t kind, int vlo, int vhi)
205 1935459
{
206 1935459
        const struct symtab *pst;
207 1935459
        struct symbol *sym, *psym;
208
209 1935459
        VTAILQ_FOREACH(sym, &st->symbols, list) {
210 974034
                if (sym->lorev > vhi || sym->hirev < vlo)
211 15850
                        continue;
212 958184
                if (kind == SYM_NONE && kind == sym->kind &&
213 958184
                    sym->wildcard == NULL)
214 0
                        continue;
215 958184
                if (tl->syntax < VCL_41 && vstrcmp(sym->name, "default") &&
216 958184
                     kind != SYM_NONE && kind != sym->kind &&
217 958184
                     sym->wildcard == NULL)
218 8
                        continue;
219 958176
                return (sym);
220 958184
        }
221 977283
        pst = st->parent;
222 977283
        if (pst == NULL)
223 0
                return (sym);
224 977283
        psym = VTAILQ_FIRST(&pst->symbols);
225 977283
        if (psym == NULL)
226 568943
                return (sym);
227 408340
        if (psym->wildcard == NULL)
228 331412
                return (sym);
229
230 76928
        sym = vcc_new_symbol(tl, st, kind, vlo, vhi);
231 76928
        psym->wildcard(tl, psym, sym);
232 76928
        if (tl->err)
233 2
                return (NULL);
234 76926
        return (sym);
235 76928
}
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
VCC_SymbolGet(struct vcc *tl, vcc_ns_t ns, vcc_kind_t kind,
268
    const struct symmode *e, const struct symxref *x)
269 912045
{
270 912045
        struct symtab *st, *st2 = NULL;
271 912045
        struct symbol *sym = NULL, *sym2 = NULL;
272 912045
        struct token *t0, *tn, *tn1, *tn2 = NULL;
273
274 912045
        AN(tl);
275 912045
        CHECK_OBJ_NOTNULL(ns, VCC_NAMESPACE_MAGIC);
276 912045
        AN(ns->name);
277 912045
        CHECK_OBJ_NOTNULL(kind, KIND_MAGIC);
278 912045
        AN(e);
279 912045
        AN(x);
280 912045
        AN(x->name);
281 912045
        if (tl->syntax >= VCL_41 && e == SYMTAB_CREATE && kind != SYM_SUB &&
282 912045
            vcc_Has_vcl_prefix(tl->t->b)) {
283 2
                VSB_cat(tl->sb, "Symbols named 'vcl_*' are reserved.\nAt:");
284 2
                vcc_ErrWhere(tl, tl->t);
285 2
                return (NULL);
286 2
        }
287
288 912043
        st = tl->syms[ns->id];
289 912043
        t0 = tl->t;
290 912043
        tn = tl->t;
291 912043
        assert(tn->tok == ID);
292 1205821
        while (1) {
293 1205821
                assert(tn->tok == ID || tn->tok == CSTR);
294 1205821
                if (tn->tok == CSTR && tl->syntax < VCL_41) {
295 1
                        VSB_cat(tl->sb,
296 1
                            "Quoted headers are available for VCL >= 4.1.\n"
297 1
                            "At:");
298 1
                        vcc_ErrWhere(tl, tn);
299 1
                        return (NULL);
300 1
                }
301 1205820
                if (tn->tok == CSTR && !vstrcmp(tn->dec, "")) {
302 2
                        VSB_cat(tl->sb,
303 2
                            "Illegal empty header name.\n"
304 2
                            "At: ");
305 2
                        vcc_ErrWhere(tl, tn);
306 2
                        return (NULL);
307 2
                }
308 1205818
                if (tn->tok == ID)
309 1205788
                        st = vcc_symtab_str(st, tn->b, tn->e, tn->tok);
310 30
                else
311 30
                        st = vcc_symtab_str(st, tn->dec, NULL, tn->tok);
312 1205818
                sym2 = vcc_sym_in_tab(tl, st, kind, tl->syntax, tl->syntax);
313 1205818
                if (sym2 != NULL) {
314 1008696
                        sym = sym2;
315 1008696
                        st2 = st;
316 1008696
                        tn2 = tn;
317 1008696
                }
318 1205818
                tn1 = vcc_PeekTokenFrom(tl, tn);
319 1205818
                if (tn1->tok != '.')
320 912038
                        break;
321 293780
                tn1 = vcc_PeekTokenFrom(tl, tn1);
322 293780
                if (tn1->tok == CSTR && (sym == NULL || sym->wildcard == NULL))
323 1
                        break;
324 293779
                if (tn1->tok != CSTR && tn1->tok != ID)
325 1
                        break;
326 293778
                tn = tn1;
327 293778
        }
328 912040
        if (sym != NULL && sym->kind == SYM_ALIAS) {
329 1
                assert(ns == SYM_MAIN);
330 1
                st = vcc_symtab_str(tl->syms[ns->id], sym->eval_priv, NULL, ID);
331 1
                AN(st);
332 1
                st2 = st;
333 1
                sym = vcc_sym_in_tab(tl, st, SYM_NONE, sym->lorev, sym->hirev);
334 1
                AN(sym);
335 1
        }
336 912040
        if (sym != NULL && sym->kind == SYM_VMOD && e->partial)
337 1
                e = SYMTAB_EXISTING;
338 912040
        if (sym != NULL && e->partial) {
339 487097
                st = st2;
340 487097
                tn = tn2;
341 487097
        } else if (st != st2) {
342 180475
                sym = NULL;
343 180475
        }
344 912040
        if (tl->err || (sym == NULL && e->noerr))
345 89917
                return (sym);
346 822123
        AN(st);
347 822123
        AN(tn);
348 822123
        if (sym == NULL && e == SYMTAB_CREATE)
349 90532
                sym = vcc_new_symbol(tl, st, kind, tl->syntax, tl->syntax);
350 822123
        tl->t = vcc_PeekTokenFrom(tl, tn);
351 822123
        if (tl->err)
352 0
                return (NULL);
353 822123
        if (sym == NULL) {
354 26
                VSB_printf(tl->sb, "%s: '", e->name);
355 26
                vcc_PrintTokens(tl, t0, tl->t);
356 26
                VSB_cat(tl->sb, "'");
357 26
                sym = vcc_sym_in_tab(tl, st, kind, VCL_LOW, VCL_HIGH);
358 26
                if (sym != NULL && sym->kind != SYM_OBJECT &&
359 26
                    sym->kind != SYM_INSTANCE) { /* XXX: too specific */
360 9
                        VSB_cat(tl->sb, " (Only available when");
361 9
                        if (sym->lorev >= VCL_LOW)
362 8
                                VSB_printf(tl->sb, " %.1f <=", .1 * sym->lorev);
363 9
                        VSB_cat(tl->sb, " VCL syntax");
364 9
                        if (sym->hirev <= VCL_HIGH)
365 1
                                VSB_printf(tl->sb, " <= %.1f", .1 * sym->hirev);
366 9
                        VSB_cat(tl->sb, ")");
367 9
                }
368 26
                VSB_cat(tl->sb, "\nAt: ");
369 26
                vcc_ErrWhere2(tl, t0, tl->t);
370 26
                return (NULL);
371 26
        }
372 822097
        if (kind != SYM_NONE && kind != sym->kind && sym->type != DEFAULT) {
373 3
                VSB_cat(tl->sb, "Symbol '");
374 3
                vcc_PrintTokens(tl, t0, tl->t);
375 3
                VSB_printf(tl->sb, "' has wrong type (%s), expected %s:",
376 3
                    sym->kind->name, kind->name);
377 3
                VSB_cat(tl->sb, "\nAt: ");
378 3
                vcc_ErrWhere2(tl, t0, tl->t);
379 3
                if (sym->def_b != NULL) {
380 2
                        VSB_cat(tl->sb, "Symbol was defined here: ");
381 2
                        vcc_ErrWhere(tl, sym->def_b);
382 2
                } else if (sym->ref_b != NULL) {
383 1
                        VSB_cat(tl->sb, "Symbol was declared here: ");
384 1
                        vcc_ErrWhere(tl, sym->ref_b);
385 1
                } else {
386 0
                        VSB_cat(tl->sb, "Symbol was builtin\n");
387 0
                }
388 3
                return (NULL);
389 3
        }
390 822094
        if (x == XREF_DEF) {
391 135157
                if (sym->def_b == NULL)
392 133492
                        sym->def_b = t0;
393 135157
                sym->ndef++;
394 686937
        } else if (x == XREF_REF) {
395 275168
                if (sym->ref_b == NULL)
396 177768
                        sym->ref_b = t0;
397 275168
                sym->nref++;
398 411769
        } else {
399 411769
                assert (x == XREF_NONE);
400 411769
        }
401 822094
        return (sym);
402 822094
}
403
404
static struct symbol *
405
vcc_TypeSymbol(struct vcc *tl, vcc_ns_t ns, vcc_kind_t kind, vcc_type_t type)
406 3825
{
407 3825
        struct token t[1], *t0;
408 3825
        struct symbol *sym;
409 3825
        struct vsb *buf;
410
411 3825
        buf = VSB_new_auto();
412 3825
        AN(buf);
413 3825
        VSB_printf(buf, "%s.%.*s", type->name, PF(tl->t));
414 3825
        AZ(VSB_finish(buf));
415
416
        /* NB: we create a fake token but errors are handled by the caller. */
417 3825
        vmemcpy(t, tl->t, sizeof *t);
418 3825
        t->b = VSB_data(buf);
419 3825
        t->e = t->b + VSB_len(buf);
420
421 3825
        t0 = tl->t;
422 3825
        tl->t = t;
423 3825
        sym = VCC_SymbolGet(tl, ns, kind, SYMTAB_NOERR, XREF_NONE);
424 3825
        tl->t = t0;
425 3825
        VSB_destroy(&buf);
426
427 3825
        return (sym);
428 3825
}
429
430
struct symbol *
431
VCC_TypeSymbol(struct vcc *tl, vcc_kind_t kind, vcc_type_t type)
432 3825
{
433
434 3825
        if (strchr(type->name, '.') == NULL)
435 3053
                return (vcc_TypeSymbol(tl, SYM_TYPE, kind, type));
436
437
        /* NB: type imported from a VMOD */
438 772
        return (vcc_TypeSymbol(tl, SYM_MAIN, kind, type));
439 3825
}
440
441
struct symbol *
442
VCC_MkSym(struct vcc *tl, const char *b, vcc_ns_t ns, vcc_kind_t kind,
443
    int vlo, int vhi)
444 729482
{
445 729482
        struct symtab *st;
446 729482
        struct symbol *sym;
447 729482
        const struct symbol *parent;
448
449 729482
        AN(tl);
450 729482
        AN(b);
451 729482
        CHECK_OBJ_NOTNULL(ns, VCC_NAMESPACE_MAGIC);
452 729482
        CHECK_OBJ_NOTNULL(kind, KIND_MAGIC);
453 729482
        assert(vlo <= vhi);
454
455 729482
        if (tl->syms[ns->id] == NULL)
456 6567
                tl->syms[ns->id] = vcc_symtab_new("");
457 729482
        st = vcc_symtab_str(tl->syms[ns->id], b, NULL, ID);
458 729482
        AN(st);
459 729482
        sym = vcc_sym_in_tab(tl, st, kind, vlo, vhi);
460 729482
        if (sym != NULL) {
461 26264
                assert(sym->kind == SYM_VAR);
462 26264
                parent = sym->eval_priv;
463 26264
                AN(parent);
464 26264
                AN(parent->wildcard);
465 26264
                assert(sym->type == parent->type);
466 26264
                return (sym);
467 26264
        }
468 703218
        AZ(sym);
469 703218
        sym = vcc_new_symbol(tl, st, kind, vlo, vhi);
470 703218
        AN(sym);
471 703218
        sym->noref = 1;
472 703218
        return (sym);
473 703218
}
474
475
struct symbol *
476
VCC_MkSymAlias(struct vcc *tl, const char *alias, const char *name)
477 132
{
478 132
        struct symbol *sym_alias, *sym;
479 132
        struct symtab *st;
480
481 132
        AN(tl);
482 132
        AN(alias);
483 132
        AN(name);
484
485 132
        st = vcc_symtab_str(tl->syms[SYM_MAIN->id], name, NULL, ID);
486 132
        AN(st);
487 132
        sym = vcc_sym_in_tab(tl, st, SYM_NONE, VCL_LOW, VCL_HIGH);
488 132
        AN(sym);
489 132
        assert(sym->kind != SYM_ALIAS);
490 132
        sym_alias = VCC_MkSym(tl, alias, SYM_MAIN, SYM_ALIAS, sym->lorev,
491 132
            sym->hirev);
492 132
        AN(sym_alias);
493 132
        sym_alias->eval_priv = strdup(name);
494 132
        AN(sym_alias->eval_priv);
495 132
        return (sym);
496 132
}
497
498
static void
499
vcc_walksymbols(struct vcc *tl, const struct symtab *root,
500
    symwalk_f *func, vcc_kind_t kind)
501 4747339
{
502 4747339
        struct symbol *sym;
503 4747339
        struct symtab *st1, *st2 = NULL;
504
505 4747339
        VTAILQ_FOREACH(sym, &root->symbols, list) {
506 4592634
                if (kind == SYM_NONE || kind == sym->kind)
507 1928109
                        func(tl, sym);
508 4592634
                ERRCHK(tl);
509 4592634
        }
510 4747283
        VTAILQ_FOREACH(st1, &root->children, list) {
511 4727328
                if (st2 != NULL)
512 4325011
                        assert(strcasecmp(st1->name, st2->name) >= 0);
513 4727328
                st2 = st1;
514 4727328
                vcc_walksymbols(tl, st1, func, kind);
515 4727328
                ERRCHK(tl);
516 4727328
        }
517 4747283
}
518
519
void
520
VCC_WalkSymbols(struct vcc *tl, symwalk_f *func, vcc_ns_t ns, vcc_kind_t kind)
521 20011
{
522
523 20011
        CHECK_OBJ_NOTNULL(ns, VCC_NAMESPACE_MAGIC);
524 20011
        vcc_walksymbols(tl, tl->syms[ns->id], func, kind);
525 20011
}
526
527
void
528
VCC_GlobalSymbol(struct symbol *sym, vcc_type_t type)
529 177739
{
530 177739
        vcc_kind_t kind;
531 177739
        struct vsb *vsb;
532
533 177739
        CHECK_OBJ_NOTNULL(sym, SYMBOL_MAGIC);
534 177739
        AN(type);
535 177739
        AN(type->global_pfx);
536
537 177739
        kind = VCC_HandleKind(type);
538
539 177739
        if (sym->lname != NULL) {
540 87848
                AN(sym->rname);
541 87848
                assert(sym->type == type);
542 87848
                assert(sym->kind == kind);
543 87848
                return;
544 87848
        }
545
546 89891
        vsb = VSB_new_auto();
547 89891
        AN(vsb);
548 89891
        VSB_printf(vsb, "%s_", type->global_pfx);
549 89891
        VCC_PrintCName(vsb, sym->name, NULL);
550 89891
        AZ(VSB_finish(vsb));
551 89891
        sym->lname = strdup(VSB_data(vsb));
552 89891
        AN(sym->lname);
553 89891
        if (type == SUB) {
554 87934
                VSB_clear(vsb);
555 87934
                VSB_printf(vsb, "sub_%s", sym->lname);
556 87934
                AZ(VSB_finish(vsb));
557 87934
        }
558 89891
        sym->rname = strdup(VSB_data(vsb));
559 89891
        AN(sym->rname);
560 89891
        VSB_destroy(&vsb);
561
562 89891
        sym->type = type;
563 89891
        sym->kind = kind;
564 89891
        if (sym->kind != SYM_NONE) {
565 89891
                AZ(VCT_invalid_name(sym->rname, NULL));
566 89891
                if (type == SUB)
567 87934
                        sym->eval = vcc_Eval_Sub;
568 1957
                else
569 1957
                        sym->eval = vcc_Eval_Handle;
570 89891
        } else {
571 0
                WRONG("Wrong kind of global symbol");
572 0
        }
573
574 1348365
#define VCL_MET_MAC(l,u,t,b)   sym->r_methods |= VCL_MET_##u;
575 89891
#include "tbl/vcl_returns.h"
576 89891
}
577
578
struct symbol *
579
VCC_HandleSymbol(struct vcc *tl, vcc_type_t fmt)
580 2060
{
581 2060
        struct symbol *sym;
582 2060
        vcc_kind_t kind;
583 2060
        struct token *t;
584 2060
        const char *p;
585
586 2060
        if (vcc_IdIs(tl->t, "default") && fmt->default_sym != NULL) {
587 101
                vcc_NextToken(tl);
588 101
                return (fmt->default_sym);
589 101
        }
590
591 1959
        kind = VCC_HandleKind(fmt);
592 1959
        assert(kind != SYM_NONE);
593
594 1959
        t = tl->t;
595 1959
        sym = VCC_SymbolGet(tl, SYM_MAIN, SYM_NONE, SYMTAB_NOERR, XREF_NONE);
596 1959
        if (sym != NULL && sym->def_b != NULL && kind == sym->kind) {
597 3
                p = sym->kind->name;
598 3
                VSB_printf(tl->sb, "%c%s '%.*s' redefined.\n",
599 3
                    toupper(*p), p + 1, PF(t));
600 3
                vcc_ErrWhere(tl, t);
601 3
                VSB_cat(tl->sb, "First definition:\n");
602 3
                AN(sym->def_b);
603 3
                vcc_ErrWhere(tl, sym->def_b);
604 3
                return (sym);
605 1956
        } else if (sym != NULL && sym->def_b != NULL) {
606 2
                VSB_printf(tl->sb, "Name '%.*s' already defined.\n", PF(t));
607 2
                vcc_ErrWhere(tl, t);
608 2
                VSB_cat(tl->sb, "First definition:\n");
609 2
                AN(sym->def_b);
610 2
                vcc_ErrWhere(tl, sym->def_b);
611 2
                return (sym);
612 1954
        } else if (sym != NULL && sym->kind != kind) {
613 1
                VSB_printf(tl->sb,
614 1
                    "Name %.*s must have type '%s'.\n",
615 1
                    PF(t), sym->kind->name);
616 1
                vcc_ErrWhere(tl, t);
617 1
                return (sym);
618 1
        }
619 1953
        if (sym == NULL)
620 1951
                sym = VCC_SymbolGet(tl, SYM_MAIN, kind, SYMTAB_CREATE,
621 1951
                    XREF_NONE);
622 1953
        if (sym == NULL)
623 0
                return (NULL);
624 1953
        AN(sym);
625 1953
        AZ(sym->ndef);
626 1953
        VCC_GlobalSymbol(sym, fmt);
627 1953
        sym->ndef = 1;
628 1953
        if (sym->def_b == NULL)
629 1953
                sym->def_b = t;
630 1953
        return (sym);
631 1953
}
632
/*lint -restore */