source: lib/libvcl/vcc_compile.h @ a88956

Revision a88956, 9.4 KB checked in by Poul-Henning Kamp <phk@…>, 3 years ago (diff)

Get rid of the last trace if the libvarnish.h kitchen-sink:
bprint macros go in vdef.h, VCS_* in vcs.h

  • Property mode set to 100644
Line 
1/*-
2 * Copyright (c) 2006 Verdens Gang AS
3 * Copyright (c) 2006-2010 Varnish Software AS
4 * All rights reserved.
5 *
6 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
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 */
30
31#include <stdint.h>
32
33#include "miniobj.h"
34#include "vas.h"
35#include "vcl.h"
36#include "vdef.h"
37#include "vqueue.h"
38#include "vsb.h"
39
40#include "vcc_token_defs.h"
41
42#ifndef NULL
43#define NULL ((void*)0)
44#endif
45
46struct vsb;
47
48#define isident1(c) (isalpha(c))
49#define isident(c) (isalpha(c) || isdigit(c) || (c) == '_' || (c) == '-')
50#define isvar(c) (isident(c) || (c) == '.')
51unsigned vcl_fixed_token(const char *p, const char **q);
52extern const char * const vcl_tnames[256];
53void vcl_output_lang_h(struct vsb *sb);
54
55#define PF(t)   (int)((t)->e - (t)->b), (t)->b
56
57#define INDENT          2
58
59struct acl_e;
60struct proc;
61struct expr;
62struct vcc;
63struct symbol;
64
65enum var_type {
66#define VCC_TYPE(foo)           foo,
67#include "tbl/vcc_types.h"
68#undef VCC_TYPE
69};
70
71struct membit {
72        VTAILQ_ENTRY(membit)    list;
73        void                    *ptr;
74};
75
76struct source {
77        VTAILQ_ENTRY(source)    list;
78        char                    *name;
79        const char              *b;
80        const char              *e;
81        unsigned                idx;
82        char                    *freeit;
83};
84
85struct token {
86        unsigned                tok;
87        const char              *b;
88        const char              *e;
89        struct source           *src;
90        VTAILQ_ENTRY(token)     list;
91        unsigned                cnt;
92        char                    *dec;
93};
94
95enum symkind {
96#define VCC_SYMB(uu, ll, dd)    SYM_##uu,
97#include "symbol_kind.h"
98#undef VCC_SYMB
99};
100
101typedef void sym_expr_t(struct vcc *tl, struct expr **, const struct symbol *sym);
102typedef struct symbol *sym_wildcard_t(struct vcc *tl, const struct token *t,
103    const struct symbol *sym);
104
105struct symbol {
106        unsigned                        magic;
107#define SYMBOL_MAGIC                    0x3368c9fb
108        VTAILQ_ENTRY(symbol)            list;
109
110        char                            *name;
111        unsigned                        nlen;
112        sym_wildcard_t                  *wildcard;
113        enum symkind                    kind;
114
115        const struct token              *def_b, *def_e;
116
117        enum var_type                   fmt;
118
119        sym_expr_t                      *eval;
120        void                            *eval_priv;
121
122        /* xref.c */
123        struct proc                     *proc;
124        unsigned                        nref, ndef;
125
126        /* SYM_PROC, SYM_FUNC */
127        const char                      *cfunc;
128        const char                      *args;
129
130        /* SYM_VAR */
131        const struct var                *var;
132        unsigned                        r_methods;
133};
134
135VTAILQ_HEAD(tokenhead, token);
136
137struct vcc {
138        unsigned                magic;
139#define VCC_MAGIC               0x24ad719d
140
141        /* Parameter/Template section */
142        char                    *default_vcl;
143        char                    *vcl_dir;
144        char                    *vmod_dir;
145
146        const struct var        *vars;
147        VTAILQ_HEAD(, symbol)   symbols;
148
149        /* Instance section */
150        struct tokenhead        tokens;
151        VTAILQ_HEAD(, source)   sources;
152        VTAILQ_HEAD(, membit)   membits;
153        VTAILQ_HEAD(, host)     hosts;
154        unsigned                nsources;
155        struct source           *src;
156        struct token            *t;
157        int                     indent;
158        int                     hindent;
159        int                     iindent;
160        int                     findent;
161        unsigned                cnt;
162
163        struct vsb              *fc;            /* C-code */
164        struct vsb              *fh;            /* H-code (before C-code) */
165        struct vsb              *fi;            /* Init func code */
166        struct vsb              *ff;            /* Finish func code */
167        struct vsb              *fb;            /* Body of current sub
168                                                 * NULL otherwise
169                                                 */
170        struct vsb              *fm[VCL_MET_MAX];       /* Method bodies */
171        struct vsb              *sb;
172        int                     err;
173        int                     ndirector;
174        struct proc             *curproc;
175        struct proc             *mprocs[VCL_MET_MAX];
176
177        VTAILQ_HEAD(, acl_e)    acl;
178
179        int                     nprobe;
180
181        int                     defaultdir;
182        struct token            *t_defaultdir;
183        struct token            *t_dir;
184        struct token            *t_policy;
185
186        unsigned                unique;
187        unsigned                nvmodpriv;
188
189        unsigned                err_unref;
190};
191
192struct var {
193        const char              *name;
194        enum var_type           fmt;
195        unsigned                len;
196        const char              *rname;
197        unsigned                r_methods;
198        const char              *lname;
199        unsigned                w_methods;
200        const char              *http;
201        const char              *hdr;
202};
203
204struct method {
205        const char              *name;
206        unsigned                ret_bitmap;
207        unsigned                bitval;
208};
209
210/*--------------------------------------------------------------------*/
211
212/* vcc_acl.c */
213
214void vcc_Acl(struct vcc *tl);
215void vcc_Acl_Hack(struct vcc *tl, char *b);
216
217/* vcc_action.c */
218int vcc_ParseAction(struct vcc *tl);
219
220/* vcc_backend.c */
221struct fld_spec;
222typedef void parsedirector_f(struct vcc *tl);
223
224void vcc_ParseProbe(struct vcc *tl);
225void vcc_ParseDirector(struct vcc *tl);
226void vcc_ParseBackendHost(struct vcc *tl, int serial, char **nm);
227struct fld_spec * vcc_FldSpec(struct vcc *tl, const char *first, ...);
228void vcc_ResetFldSpec(struct fld_spec *f);
229void vcc_IsField(struct vcc *tl, struct token **t, struct fld_spec *fs);
230void vcc_FieldsOk(struct vcc *tl, const struct fld_spec *fs);
231
232void Emit_Sockaddr(struct vcc *tl, const struct token *t_host, const char *port);
233
234/* vcc_compile.c */
235extern struct method method_tab[];
236/*
237 * H -> Header, before the C code
238 * C -> C-code
239 * B -> Body of function, ends up in C once function is completed
240 * I -> Initializer function
241 * F -> Finish function
242 */
243void Fh(const struct vcc *tl, int indent, const char *fmt, ...);
244void Fc(const struct vcc *tl, int indent, const char *fmt, ...);
245void Fb(const struct vcc *tl, int indent, const char *fmt, ...);
246void Fi(const struct vcc *tl, int indent, const char *fmt, ...);
247void Ff(const struct vcc *tl, int indent, const char *fmt, ...);
248void EncToken(struct vsb *sb, const struct token *t);
249int IsMethod(const struct token *t);
250void *TlAlloc(struct vcc *tl, unsigned len);
251char *TlDup(struct vcc *tl, const char *s);
252char *TlDupTok(struct vcc *tl, const struct token *tok);
253
254void EncString(struct vsb *sb, const char *b, const char *e, int mode);
255
256/* vcc_dir_random.c */
257parsedirector_f vcc_ParseRandomDirector;
258
259/* vcc_dir_round_robin.c */
260parsedirector_f vcc_ParseRoundRobinDirector;
261
262/* vcc_expr.c */
263void vcc_RTimeVal(struct vcc *tl, double *);
264void vcc_TimeVal(struct vcc *tl, double *);
265unsigned vcc_UintVal(struct vcc *tl);
266void vcc_Expr(struct vcc *tl, enum var_type typ);
267void vcc_Expr_Call(struct vcc *tl, const struct symbol *sym);
268void vcc_Expr_Init(struct vcc *tl);
269sym_expr_t vcc_Eval_Var;
270sym_expr_t vcc_Eval_Func;
271sym_expr_t vcc_Eval_Backend;
272
273/* vcc_dir_dns.c */
274parsedirector_f vcc_ParseDnsDirector;
275
276/* vcc_obj.c */
277extern const struct var vcc_vars[];
278
279/* vcc_parse.c */
280void vcc_Parse(struct vcc *tl);
281
282/* vcc_storage.c */
283sym_wildcard_t vcc_Stv_Wildcard;
284
285/* vcc_string.c */
286char *vcc_regexp(struct vcc *tl);
287
288/* vcc_symb.c */
289struct symbol *VCC_AddSymbolStr(struct vcc *tl, const char *name, enum symkind);
290struct symbol *VCC_AddSymbolTok(struct vcc *tl, const struct token *t, enum symkind kind);
291struct symbol *VCC_GetSymbolTok(struct vcc *tl, const struct token *tok,
292    enum symkind);
293struct symbol *VCC_FindSymbol(struct vcc *tl,
294    const struct token *t, enum symkind kind);
295const char * VCC_SymKind(struct vcc *tl, const struct symbol *s);
296typedef void symwalk_f(struct vcc *tl, const struct symbol *s);
297void VCC_WalkSymbols(struct vcc *tl, symwalk_f *func, enum symkind kind);
298
299/* vcc_token.c */
300void vcc_Coord(const struct vcc *tl, struct vsb *vsb,
301    const struct token *t);
302void vcc_ErrToken(const struct vcc *tl, const struct token *t);
303void vcc_ErrWhere(struct vcc *, const struct token *);
304void vcc_ErrWhere2(struct vcc *, const struct token *, const struct token *);
305
306void vcc__Expect(struct vcc *tl, unsigned tok, int line);
307int vcc_Teq(const struct token *t1, const struct token *t2);
308int vcc_IdIs(const struct token *t, const char *p);
309void vcc_ExpectCid(struct vcc *tl);
310void vcc_Lexer(struct vcc *tl, struct source *sp);
311void vcc_NextToken(struct vcc *tl);
312void vcc__ErrInternal(struct vcc *tl, const char *func,
313    unsigned line);
314void vcc_AddToken(struct vcc *tl, unsigned tok, const char *b,
315    const char *e);
316
317/* vcc_var.c */
318sym_wildcard_t vcc_Var_Wildcard;
319const struct var *vcc_FindVar(struct vcc *tl, const struct token *t,
320    int wr_access, const char *use);
321
322/* vcc_vmod.c */
323void vcc_ParseImport(struct vcc *tl);
324
325/* vcc_xref.c */
326int vcc_AddDef(struct vcc *tl, const struct token *t, enum symkind type);
327void vcc_AddRef(struct vcc *tl, const struct token *t, enum symkind type);
328int vcc_CheckReferences(struct vcc *tl);
329
330void vcc_AddCall(struct vcc *tl, struct token *t);
331struct proc *vcc_AddProc(struct vcc *tl, struct token *t);
332void vcc_ProcAction(struct proc *p, unsigned action, struct token *t);
333int vcc_CheckAction(struct vcc *tl);
334void vcc_AddUses(struct vcc *tl, const struct token *t, unsigned mask,
335    const char *use);
336int vcc_CheckUses(struct vcc *tl);
337
338#define ERRCHK(tl)      do { if ((tl)->err) return; } while (0)
339#define ErrInternal(tl) vcc__ErrInternal(tl, __func__, __LINE__)
340#define Expect(a, b) vcc__Expect(a, b, __LINE__)
341#define ExpectErr(a, b) \
342    do { vcc__Expect(a, b, __LINE__); ERRCHK(a);} while (0)
343#define SkipToken(a, b) \
344    do { vcc__Expect(a, b, __LINE__); ERRCHK(a); vcc_NextToken(a); } while (0)
Note: See TracBrowser for help on using the repository browser.