1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
/*
* upb - a minimalist implementation of protocol buffers.
*
* vtable declarations for types that are implementing any of the src or sink
* interfaces. Only components that are implementing these interfaces need
* to worry about this file.
*
* Copyright (c) 2010 Joshua Haberman. See LICENSE for details.
*/
#ifndef UPB_SRCSINK_VTBL_H_
#define UPB_SRCSINK_VTBL_H_
#include <assert.h>
#include "upb_stream.h"
#ifdef __cplusplus
extern "C" {
#endif
// Typedefs for function pointers to all of the virtual functions.
// upb_bytesrc.
typedef bool (*upb_bytesrc_get_fptr)(
upb_bytesrc *src, upb_string *str, upb_strlen_t minlen);
typedef bool (*upb_bytesrc_append_fptr)(
upb_bytesrc *src, upb_string *str, upb_strlen_t len);
// upb_bytesink.
typedef int32_t (*upb_bytesink_put_fptr)(upb_bytesink *sink, upb_string *str);
// Vtables for the above interfaces.
typedef struct {
upb_bytesrc_get_fptr get;
upb_bytesrc_append_fptr append;
} upb_bytesrc_vtable;
typedef struct {
upb_bytesink_put_fptr put;
} upb_bytesink_vtable;
// "Base Class" definitions; components that implement these interfaces should
// contain one of these structures.
struct _upb_bytesrc {
upb_bytesrc_vtable *vtbl;
upb_status status;
bool eof;
};
struct _upb_bytesink {
upb_bytesink_vtable *vtbl;
upb_status status;
bool eof;
};
INLINE void upb_bytesrc_init(upb_bytesrc *s, upb_bytesrc_vtable *vtbl) {
s->vtbl = vtbl;
s->eof = false;
upb_status_init(&s->status);
}
INLINE void upb_bytesink_init(upb_bytesink *s, upb_bytesink_vtable *vtbl) {
s->vtbl = vtbl;
s->eof = false;
upb_status_init(&s->status);
}
// Implementation of virtual function dispatch.
// upb_bytesrc
INLINE bool upb_bytesrc_get(
upb_bytesrc *bytesrc, upb_string *str, upb_strlen_t minlen) {
return bytesrc->vtbl->get(bytesrc, str, minlen);
}
INLINE bool upb_bytesrc_append(
upb_bytesrc *bytesrc, upb_string *str, upb_strlen_t len) {
return bytesrc->vtbl->append(bytesrc, str, len);
}
INLINE upb_status *upb_bytesrc_status(upb_bytesrc *src) { return &src->status; }
INLINE bool upb_bytesrc_eof(upb_bytesrc *src) { return src->eof; }
// upb_handlers
struct _upb_handlers {
upb_handlerset *set;
void *closure;
};
INLINE void upb_handlers_init(upb_handlers *h) {
(void)h;
}
INLINE void upb_handlers_uninit(upb_handlers *h) {
(void)h;
}
INLINE void upb_handlers_reset(upb_handlers *h) {
h->set = NULL;
h->closure = NULL;
}
INLINE bool upb_handlers_isempty(upb_handlers *h) {
return !h->set && !h->closure;
}
INLINE void upb_register_handlerset(upb_handlers *h, upb_handlerset *set) {
h->set = set;
}
INLINE void upb_set_handler_closure(upb_handlers *h, void *closure) {
h->closure = closure;
}
// upb_dispatcher
typedef struct {
upb_handlers handlers;
int depth;
} upb_dispatcher_frame;
struct _upb_dispatcher {
upb_dispatcher_frame stack[UPB_MAX_NESTING], *top, *limit;
};
INLINE void upb_dispatcher_init(upb_dispatcher *d) {
d->limit = d->stack + sizeof(d->stack);
}
INLINE void upb_dispatcher_reset(upb_dispatcher *d, upb_handlers *h) {
d->top = d->stack;
d->top->depth = 1; // Never want to trigger end-of-delegation.
d->top->handlers = *h;
}
INLINE void upb_dispatch_startmsg(upb_dispatcher *d) {
assert(d->stack == d->top);
d->top->handlers.set->startmsg(d->top->handlers.closure);
}
INLINE void upb_dispatch_endmsg(upb_dispatcher *d) {
assert(d->stack == d->top);
d->top->handlers.set->endmsg(d->top->handlers.closure);
}
INLINE upb_flow_t upb_dispatch_startsubmsg(upb_dispatcher *d,
struct _upb_fielddef *f) {
upb_handlers handlers;
upb_handlers_init(&handlers);
upb_handlers_reset(&handlers);
upb_flow_t ret = d->top->handlers.set->startsubmsg(d->top->handlers.closure, f, &handlers);
assert((ret == UPB_DELEGATE) == !upb_handlers_isempty(&handlers));
if (ret == UPB_DELEGATE) {
++d->top;
d->top->handlers = handlers;
d->top->depth = 0;
d->top->handlers.set->startmsg(d->top->handlers.closure);
ret = UPB_CONTINUE;
}
++d->top->depth;
upb_handlers_uninit(&handlers);
return ret;
}
INLINE upb_flow_t upb_dispatch_endsubmsg(upb_dispatcher *d) {
if (--d->top->depth == 0) {
d->top->handlers.set->endmsg(d->top->handlers.closure);
--d->top;
}
return d->top->handlers.set->endsubmsg(d->top->handlers.closure);
}
INLINE upb_flow_t upb_dispatch_value(upb_dispatcher *d,
struct _upb_fielddef *f,
upb_value val) {
return d->top->handlers.set->value(d->top->handlers.closure, f, val);
}
INLINE upb_flow_t upb_dispatch_unknownval(upb_dispatcher *d,
upb_field_number_t fieldnum,
upb_value val) {
return d->top->handlers.set->unknownval(d->top->handlers.closure,
fieldnum, val);
}
// upb_bytesink
INLINE int32_t upb_bytesink_put(upb_bytesink *sink, upb_string *str) {
return sink->vtbl->put(sink, str);
}
INLINE upb_status *upb_bytesink_status(upb_bytesink *sink) {
return &sink->status;
}
// upb_bytesink
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif
|
