Added generic API for date range validation (with callbacks).
[BearSSL] / codec / pemdec.c
1 /* Automatically generated code; do not modify directly. */
2
3 #include <stddef.h>
4 #include <stdint.h>
5
6 typedef struct {
7 uint32_t *dp;
8 uint32_t *rp;
9 const unsigned char *ip;
10 } t0_context;
11
12 static uint32_t
13 t0_parse7E_unsigned(const unsigned char **p)
14 {
15 uint32_t x;
16
17 x = 0;
18 for (;;) {
19 unsigned y;
20
21 y = *(*p) ++;
22 x = (x << 7) | (uint32_t)(y & 0x7F);
23 if (y < 0x80) {
24 return x;
25 }
26 }
27 }
28
29 static int32_t
30 t0_parse7E_signed(const unsigned char **p)
31 {
32 int neg;
33 uint32_t x;
34
35 neg = ((**p) >> 6) & 1;
36 x = (uint32_t)-neg;
37 for (;;) {
38 unsigned y;
39
40 y = *(*p) ++;
41 x = (x << 7) | (uint32_t)(y & 0x7F);
42 if (y < 0x80) {
43 if (neg) {
44 return -(int32_t)~x - 1;
45 } else {
46 return (int32_t)x;
47 }
48 }
49 }
50 }
51
52 #define T0_VBYTE(x, n) (unsigned char)((((uint32_t)(x) >> (n)) & 0x7F) | 0x80)
53 #define T0_FBYTE(x, n) (unsigned char)(((uint32_t)(x) >> (n)) & 0x7F)
54 #define T0_SBYTE(x) (unsigned char)((((uint32_t)(x) >> 28) + 0xF8) ^ 0xF8)
55 #define T0_INT1(x) T0_FBYTE(x, 0)
56 #define T0_INT2(x) T0_VBYTE(x, 7), T0_FBYTE(x, 0)
57 #define T0_INT3(x) T0_VBYTE(x, 14), T0_VBYTE(x, 7), T0_FBYTE(x, 0)
58 #define T0_INT4(x) T0_VBYTE(x, 21), T0_VBYTE(x, 14), T0_VBYTE(x, 7), T0_FBYTE(x, 0)
59 #define T0_INT5(x) T0_SBYTE(x), T0_VBYTE(x, 21), T0_VBYTE(x, 14), T0_VBYTE(x, 7), T0_FBYTE(x, 0)
60
61 static const uint8_t t0_datablock[];
62
63
64 void br_pem_decoder_init_main(void *t0ctx);
65
66 void br_pem_decoder_run(void *t0ctx);
67
68
69
70 #include "inner.h"
71
72 #define CTX ((br_pem_decoder_context *)((unsigned char *)t0ctx - offsetof(br_pem_decoder_context, cpu)))
73
74 /* see bearssl_pem.h */
75 void
76 br_pem_decoder_init(br_pem_decoder_context *ctx)
77 {
78 memset(ctx, 0, sizeof *ctx);
79 ctx->cpu.dp = &ctx->dp_stack[0];
80 ctx->cpu.rp = &ctx->rp_stack[0];
81 br_pem_decoder_init_main(&ctx->cpu);
82 br_pem_decoder_run(&ctx->cpu);
83 }
84
85 /* see bearssl_pem.h */
86 size_t
87 br_pem_decoder_push(br_pem_decoder_context *ctx,
88 const void *data, size_t len)
89 {
90 if (ctx->event) {
91 return 0;
92 }
93 ctx->hbuf = data;
94 ctx->hlen = len;
95 br_pem_decoder_run(&ctx->cpu);
96 return len - ctx->hlen;
97 }
98
99 /* see bearssl_pem.h */
100 int
101 br_pem_decoder_event(br_pem_decoder_context *ctx)
102 {
103 int event;
104
105 event = ctx->event;
106 ctx->event = 0;
107 return event;
108 }
109
110
111
112 static const uint8_t t0_datablock[] = {
113 0x00, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x42, 0x45, 0x47, 0x49, 0x4E, 0x20,
114 0x00, 0x2D, 0x2D, 0x2D, 0x2D, 0x45, 0x4E, 0x44, 0x20, 0x00
115 };
116
117 static const uint8_t t0_codeblock[] = {
118 0x00, 0x01, 0x00, 0x09, 0x00, 0x00, 0x01, 0x01, 0x07, 0x00, 0x00, 0x01,
119 0x01, 0x08, 0x00, 0x00, 0x13, 0x13, 0x00, 0x00, 0x01,
120 T0_INT2(offsetof(br_pem_decoder_context, event)), 0x00, 0x00, 0x01,
121 T0_INT2(offsetof(br_pem_decoder_context, name)), 0x00, 0x00, 0x05,
122 0x14, 0x2C, 0x14, 0x01, 0x0A, 0x0D, 0x06, 0x03, 0x13, 0x04, 0x76, 0x01,
123 0x2D, 0x0C, 0x06, 0x05, 0x2E, 0x01, 0x03, 0x2D, 0x00, 0x01, 0x0D, 0x27,
124 0x05, 0x04, 0x01, 0x03, 0x2D, 0x00, 0x15, 0x2E, 0x01, 0x02, 0x2D, 0x00,
125 0x01, 0x01, 0x7F, 0x03, 0x00, 0x24, 0x01, 0x00, 0x17, 0x0D, 0x06, 0x03,
126 0x13, 0x04, 0x3C, 0x01, 0x7F, 0x17, 0x0D, 0x06, 0x13, 0x13, 0x02, 0x00,
127 0x05, 0x06, 0x2E, 0x01, 0x03, 0x2D, 0x04, 0x03, 0x01, 0x7F, 0x22, 0x01,
128 0x00, 0x00, 0x04, 0x23, 0x01, 0x01, 0x17, 0x0D, 0x06, 0x09, 0x13, 0x01,
129 0x00, 0x22, 0x01, 0x00, 0x00, 0x04, 0x14, 0x01, 0x02, 0x17, 0x0D, 0x06,
130 0x06, 0x13, 0x01, 0x7F, 0x00, 0x04, 0x08, 0x13, 0x01, 0x03, 0x2D, 0x01,
131 0x00, 0x00, 0x13, 0x01, 0x00, 0x03, 0x00, 0x04, 0xFF, 0x33, 0x01, 0x2C,
132 0x14, 0x01, 0x2D, 0x0D, 0x06, 0x04, 0x13, 0x01, 0x7F, 0x00, 0x14, 0x31,
133 0x06, 0x02, 0x13, 0x29, 0x14, 0x01, 0x0A, 0x0D, 0x06, 0x04, 0x13, 0x01,
134 0x02, 0x00, 0x25, 0x14, 0x1C, 0x06, 0x05, 0x13, 0x2E, 0x01, 0x03, 0x00,
135 0x03, 0x00, 0x29, 0x14, 0x01, 0x0A, 0x0D, 0x06, 0x04, 0x13, 0x01, 0x03,
136 0x00, 0x25, 0x14, 0x1C, 0x06, 0x05, 0x13, 0x2E, 0x01, 0x03, 0x00, 0x02,
137 0x00, 0x01, 0x06, 0x0A, 0x07, 0x03, 0x00, 0x29, 0x14, 0x01, 0x0A, 0x0D,
138 0x06, 0x04, 0x13, 0x01, 0x03, 0x00, 0x14, 0x01, 0x3D, 0x0D, 0x06, 0x2E,
139 0x13, 0x29, 0x14, 0x01, 0x0A, 0x0D, 0x06, 0x04, 0x13, 0x01, 0x03, 0x00,
140 0x2F, 0x05, 0x04, 0x13, 0x01, 0x03, 0x00, 0x01, 0x3D, 0x0C, 0x06, 0x03,
141 0x01, 0x03, 0x00, 0x02, 0x00, 0x01, 0x0F, 0x10, 0x06, 0x03, 0x01, 0x03,
142 0x00, 0x02, 0x00, 0x01, 0x04, 0x0F, 0x1B, 0x01, 0x01, 0x00, 0x25, 0x14,
143 0x1C, 0x06, 0x05, 0x13, 0x2E, 0x01, 0x03, 0x00, 0x02, 0x00, 0x01, 0x06,
144 0x0A, 0x07, 0x03, 0x00, 0x29, 0x14, 0x01, 0x0A, 0x0D, 0x06, 0x04, 0x13,
145 0x01, 0x03, 0x00, 0x14, 0x01, 0x3D, 0x0D, 0x06, 0x20, 0x13, 0x2F, 0x05,
146 0x03, 0x01, 0x03, 0x00, 0x02, 0x00, 0x01, 0x03, 0x10, 0x06, 0x03, 0x01,
147 0x03, 0x00, 0x02, 0x00, 0x01, 0x0A, 0x0F, 0x1B, 0x02, 0x00, 0x01, 0x02,
148 0x0F, 0x1B, 0x01, 0x01, 0x00, 0x25, 0x14, 0x1C, 0x06, 0x05, 0x13, 0x2E,
149 0x01, 0x03, 0x00, 0x02, 0x00, 0x01, 0x06, 0x0A, 0x07, 0x03, 0x00, 0x02,
150 0x00, 0x01, 0x10, 0x0F, 0x1B, 0x02, 0x00, 0x01, 0x08, 0x0F, 0x1B, 0x02,
151 0x00, 0x1B, 0x01, 0x00, 0x00, 0x00, 0x14, 0x14, 0x01, 0x80, 0x41, 0x0E,
152 0x1A, 0x01, 0x80, 0x5A, 0x0B, 0x10, 0x06, 0x05, 0x01, 0x80, 0x41, 0x08,
153 0x00, 0x14, 0x14, 0x01, 0x80, 0x61, 0x0E, 0x1A, 0x01, 0x80, 0x7A, 0x0B,
154 0x10, 0x06, 0x05, 0x01, 0x80, 0x47, 0x08, 0x00, 0x14, 0x14, 0x01, 0x30,
155 0x0E, 0x1A, 0x01, 0x39, 0x0B, 0x10, 0x06, 0x04, 0x01, 0x04, 0x07, 0x00,
156 0x14, 0x01, 0x2B, 0x0D, 0x06, 0x04, 0x13, 0x01, 0x3E, 0x00, 0x14, 0x01,
157 0x2F, 0x0D, 0x06, 0x04, 0x13, 0x01, 0x3F, 0x00, 0x01, 0x3D, 0x0C, 0x1E,
158 0x00, 0x00, 0x28, 0x01, 0x01, 0x2D, 0x23, 0x06, 0x02, 0x04, 0x7B, 0x04,
159 0x75, 0x00, 0x14, 0x12, 0x2A, 0x14, 0x05, 0x04, 0x1F, 0x01, 0x7F, 0x00,
160 0x2C, 0x2A, 0x14, 0x01, 0x0A, 0x0D, 0x06, 0x05, 0x13, 0x1F, 0x01, 0x00,
161 0x00, 0x0D, 0x05, 0x05, 0x13, 0x2E, 0x01, 0x00, 0x00, 0x1D, 0x04, 0x5E,
162 0x00, 0x01, 0x01, 0x27, 0x06, 0x0B, 0x21, 0x01, 0x80, 0x7F, 0x2B, 0x14,
163 0x06, 0x02, 0x30, 0x00, 0x13, 0x04, 0x6E, 0x00, 0x2C, 0x14, 0x31, 0x05,
164 0x01, 0x00, 0x13, 0x04, 0x77, 0x00, 0x14, 0x14, 0x01, 0x80, 0x61, 0x0E,
165 0x1A, 0x01, 0x80, 0x7A, 0x0B, 0x10, 0x06, 0x03, 0x01, 0x20, 0x08, 0x00,
166 0x01, 0x14, 0x03, 0x00, 0x1A, 0x17, 0x05, 0x05, 0x1F, 0x2E, 0x01, 0x00,
167 0x00, 0x2C, 0x14, 0x01, 0x0A, 0x0D, 0x06, 0x06, 0x1F, 0x02, 0x00, 0x1A,
168 0x08, 0x00, 0x2A, 0x17, 0x19, 0x1D, 0x1A, 0x1E, 0x1A, 0x04, 0x62, 0x00,
169 0x18, 0x14, 0x1C, 0x05, 0x01, 0x00, 0x13, 0x11, 0x04, 0x76, 0x00, 0x20,
170 0x19, 0x11, 0x00, 0x00, 0x2C, 0x01, 0x0A, 0x0C, 0x06, 0x02, 0x04, 0x78,
171 0x00, 0x01, 0x01, 0x7F, 0x03, 0x00, 0x2C, 0x14, 0x01, 0x0A, 0x0C, 0x06,
172 0x09, 0x31, 0x05, 0x04, 0x01, 0x00, 0x03, 0x00, 0x04, 0x70, 0x13, 0x02,
173 0x00, 0x00, 0x00, 0x14, 0x06, 0x14, 0x1E, 0x14, 0x21, 0x07, 0x16, 0x01,
174 0x2D, 0x0C, 0x06, 0x08, 0x21, 0x07, 0x1D, 0x01, 0x00, 0x1A, 0x19, 0x00,
175 0x04, 0x69, 0x21, 0x19, 0x00, 0x00, 0x14, 0x01, 0x0A, 0x0C, 0x1A, 0x01,
176 0x20, 0x0B, 0x10, 0x00
177 };
178
179 static const uint16_t t0_caddr[] = {
180 0,
181 5,
182 10,
183 15,
184 19,
185 24,
186 29,
187 67,
188 149,
189 384,
190 464,
191 476,
192 511,
193 530,
194 540,
195 559,
196 594,
197 605,
198 610,
199 620,
200 645,
201 672
202 };
203
204 #define T0_INTERPRETED 28
205
206 #define T0_ENTER(ip, rp, slot) do { \
207 const unsigned char *t0_newip; \
208 uint32_t t0_lnum; \
209 t0_newip = &t0_codeblock[t0_caddr[(slot) - T0_INTERPRETED]]; \
210 t0_lnum = t0_parse7E_unsigned(&t0_newip); \
211 (rp) += t0_lnum; \
212 *((rp) ++) = (uint32_t)((ip) - &t0_codeblock[0]) + (t0_lnum << 16); \
213 (ip) = t0_newip; \
214 } while (0)
215
216 #define T0_DEFENTRY(name, slot) \
217 void \
218 name(void *ctx) \
219 { \
220 t0_context *t0ctx = ctx; \
221 t0ctx->ip = &t0_codeblock[0]; \
222 T0_ENTER(t0ctx->ip, t0ctx->rp, slot); \
223 }
224
225 T0_DEFENTRY(br_pem_decoder_init_main, 38)
226
227 void
228 br_pem_decoder_run(void *t0ctx)
229 {
230 uint32_t *dp, *rp;
231 const unsigned char *ip;
232
233 #define T0_LOCAL(x) (*(rp - 2 - (x)))
234 #define T0_POP() (*-- dp)
235 #define T0_POPi() (*(int32_t *)(-- dp))
236 #define T0_PEEK(x) (*(dp - 1 - (x)))
237 #define T0_PEEKi(x) (*(int32_t *)(dp - 1 - (x)))
238 #define T0_PUSH(v) do { *dp = (v); dp ++; } while (0)
239 #define T0_PUSHi(v) do { *(int32_t *)dp = (v); dp ++; } while (0)
240 #define T0_RPOP() (*-- rp)
241 #define T0_RPOPi() (*(int32_t *)(-- rp))
242 #define T0_RPUSH(v) do { *rp = (v); rp ++; } while (0)
243 #define T0_RPUSHi(v) do { *(int32_t *)rp = (v); rp ++; } while (0)
244 #define T0_ROLL(x) do { \
245 size_t t0len = (size_t)(x); \
246 uint32_t t0tmp = *(dp - 1 - t0len); \
247 memmove(dp - t0len - 1, dp - t0len, t0len * sizeof *dp); \
248 *(dp - 1) = t0tmp; \
249 } while (0)
250 #define T0_SWAP() do { \
251 uint32_t t0tmp = *(dp - 2); \
252 *(dp - 2) = *(dp - 1); \
253 *(dp - 1) = t0tmp; \
254 } while (0)
255 #define T0_ROT() do { \
256 uint32_t t0tmp = *(dp - 3); \
257 *(dp - 3) = *(dp - 2); \
258 *(dp - 2) = *(dp - 1); \
259 *(dp - 1) = t0tmp; \
260 } while (0)
261 #define T0_NROT() do { \
262 uint32_t t0tmp = *(dp - 1); \
263 *(dp - 1) = *(dp - 2); \
264 *(dp - 2) = *(dp - 3); \
265 *(dp - 3) = t0tmp; \
266 } while (0)
267 #define T0_PICK(x) do { \
268 uint32_t t0depth = (x); \
269 T0_PUSH(T0_PEEK(t0depth)); \
270 } while (0)
271 #define T0_CO() do { \
272 goto t0_exit; \
273 } while (0)
274 #define T0_RET() break
275
276 dp = ((t0_context *)t0ctx)->dp;
277 rp = ((t0_context *)t0ctx)->rp;
278 ip = ((t0_context *)t0ctx)->ip;
279 for (;;) {
280 uint32_t t0x;
281
282 t0x = t0_parse7E_unsigned(&ip);
283 if (t0x < T0_INTERPRETED) {
284 switch (t0x) {
285 int32_t t0off;
286
287 case 0: /* ret */
288 t0x = T0_RPOP();
289 rp -= (t0x >> 16);
290 t0x &= 0xFFFF;
291 if (t0x == 0) {
292 ip = NULL;
293 goto t0_exit;
294 }
295 ip = &t0_codeblock[t0x];
296 break;
297 case 1: /* literal constant */
298 T0_PUSHi(t0_parse7E_signed(&ip));
299 break;
300 case 2: /* read local */
301 T0_PUSH(T0_LOCAL(t0_parse7E_unsigned(&ip)));
302 break;
303 case 3: /* write local */
304 T0_LOCAL(t0_parse7E_unsigned(&ip)) = T0_POP();
305 break;
306 case 4: /* jump */
307 t0off = t0_parse7E_signed(&ip);
308 ip += t0off;
309 break;
310 case 5: /* jump if */
311 t0off = t0_parse7E_signed(&ip);
312 if (T0_POP()) {
313 ip += t0off;
314 }
315 break;
316 case 6: /* jump if not */
317 t0off = t0_parse7E_signed(&ip);
318 if (!T0_POP()) {
319 ip += t0off;
320 }
321 break;
322 case 7: {
323 /* + */
324
325 uint32_t b = T0_POP();
326 uint32_t a = T0_POP();
327 T0_PUSH(a + b);
328
329 }
330 break;
331 case 8: {
332 /* - */
333
334 uint32_t b = T0_POP();
335 uint32_t a = T0_POP();
336 T0_PUSH(a - b);
337
338 }
339 break;
340 case 9: {
341 /* < */
342
343 int32_t b = T0_POPi();
344 int32_t a = T0_POPi();
345 T0_PUSH(-(uint32_t)(a < b));
346
347 }
348 break;
349 case 10: {
350 /* << */
351
352 int c = (int)T0_POPi();
353 uint32_t x = T0_POP();
354 T0_PUSH(x << c);
355
356 }
357 break;
358 case 11: {
359 /* <= */
360
361 int32_t b = T0_POPi();
362 int32_t a = T0_POPi();
363 T0_PUSH(-(uint32_t)(a <= b));
364
365 }
366 break;
367 case 12: {
368 /* <> */
369
370 uint32_t b = T0_POP();
371 uint32_t a = T0_POP();
372 T0_PUSH(-(uint32_t)(a != b));
373
374 }
375 break;
376 case 13: {
377 /* = */
378
379 uint32_t b = T0_POP();
380 uint32_t a = T0_POP();
381 T0_PUSH(-(uint32_t)(a == b));
382
383 }
384 break;
385 case 14: {
386 /* >= */
387
388 int32_t b = T0_POPi();
389 int32_t a = T0_POPi();
390 T0_PUSH(-(uint32_t)(a >= b));
391
392 }
393 break;
394 case 15: {
395 /* >> */
396
397 int c = (int)T0_POPi();
398 int32_t x = T0_POPi();
399 T0_PUSHi(x >> c);
400
401 }
402 break;
403 case 16: {
404 /* and */
405
406 uint32_t b = T0_POP();
407 uint32_t a = T0_POP();
408 T0_PUSH(a & b);
409
410 }
411 break;
412 case 17: {
413 /* co */
414 T0_CO();
415 }
416 break;
417 case 18: {
418 /* data-get8 */
419
420 size_t addr = T0_POP();
421 T0_PUSH(t0_datablock[addr]);
422
423 }
424 break;
425 case 19: {
426 /* drop */
427 (void)T0_POP();
428 }
429 break;
430 case 20: {
431 /* dup */
432 T0_PUSH(T0_PEEK(0));
433 }
434 break;
435 case 21: {
436 /* flush-buf */
437
438 if (CTX->ptr > 0) {
439 CTX->dest(CTX->dest_ctx, CTX->buf, CTX->ptr);
440 CTX->ptr = 0;
441 }
442
443 }
444 break;
445 case 22: {
446 /* get8 */
447
448 size_t addr = T0_POP();
449 T0_PUSH(*((unsigned char *)CTX + addr));
450
451 }
452 break;
453 case 23: {
454 /* over */
455 T0_PUSH(T0_PEEK(1));
456 }
457 break;
458 case 24: {
459 /* read8-native */
460
461 if (CTX->hlen > 0) {
462 T0_PUSH(*CTX->hbuf ++);
463 CTX->hlen --;
464 } else {
465 T0_PUSHi(-1);
466 }
467
468 }
469 break;
470 case 25: {
471 /* set8 */
472
473 size_t addr = T0_POP();
474 unsigned x = T0_POP();
475 *((unsigned char *)CTX + addr) = x;
476
477 }
478 break;
479 case 26: {
480 /* swap */
481 T0_SWAP();
482 }
483 break;
484 case 27: {
485 /* write8 */
486
487 unsigned char x = (unsigned char)T0_POP();
488 CTX->buf[CTX->ptr ++] = x;
489 if (CTX->ptr == sizeof CTX->buf) {
490 if (CTX->dest) {
491 CTX->dest(CTX->dest_ctx, CTX->buf, sizeof CTX->buf);
492 }
493 CTX->ptr = 0;
494 }
495
496 }
497 break;
498 }
499
500 } else {
501 T0_ENTER(ip, rp, t0x);
502 }
503 }
504 t0_exit:
505 ((t0_context *)t0ctx)->dp = dp;
506 ((t0_context *)t0ctx)->rp = rp;
507 ((t0_context *)t0ctx)->ip = ip;
508 }