1/* Automatically generated code; do not modify directly. */
2
3#include <stddef.h>
4#include <stdint.h>
5
6typedef struct {
7	uint32_t *dp;
8	uint32_t *rp;
9	const unsigned char *ip;
10} t0_context;
11
12static uint32_t
13t0_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
29static int32_t
30t0_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 unsigned char t0_datablock[]; */
62
63
64void br_pem_decoder_init_main(void *t0ctx);
65
66void br_pem_decoder_run(void *t0ctx);
67
68
69
70#include "inner.h"
71
72#define CTX   ((br_pem_decoder_context *)(void *)((unsigned char *)t0ctx - offsetof(br_pem_decoder_context, cpu)))
73
74/* see bearssl_pem.h */
75void
76br_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 */
86size_t
87br_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 */
100int
101br_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
112static const unsigned char 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
117static const unsigned char 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, 0x25, 0x01, 0x00, 0x18, 0x0D, 0x06, 0x03,
126	0x13, 0x04, 0x3C, 0x01, 0x7F, 0x18, 0x0D, 0x06, 0x13, 0x13, 0x02, 0x00,
127	0x05, 0x06, 0x2E, 0x01, 0x03, 0x2D, 0x04, 0x03, 0x01, 0x7F, 0x23, 0x01,
128	0x00, 0x00, 0x04, 0x23, 0x01, 0x01, 0x18, 0x0D, 0x06, 0x09, 0x13, 0x01,
129	0x00, 0x23, 0x01, 0x00, 0x00, 0x04, 0x14, 0x01, 0x02, 0x18, 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, 0x16, 0x14, 0x1D, 0x06, 0x05, 0x13, 0x2E, 0x01, 0x03, 0x00,
135	0x03, 0x00, 0x29, 0x14, 0x01, 0x0A, 0x0D, 0x06, 0x04, 0x13, 0x01, 0x03,
136	0x00, 0x16, 0x14, 0x1D, 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, 0x1C, 0x01, 0x01, 0x00, 0x16, 0x14,
143	0x1D, 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, 0x1C, 0x02, 0x00, 0x01, 0x02,
148	0x0F, 0x1C, 0x01, 0x01, 0x00, 0x16, 0x14, 0x1D, 0x06, 0x05, 0x13, 0x2E,
149	0x01, 0x03, 0x00, 0x02, 0x00, 0x01, 0x06, 0x0A, 0x07, 0x03, 0x00, 0x02,
150	0x00, 0x01, 0x10, 0x0F, 0x1C, 0x02, 0x00, 0x01, 0x08, 0x0F, 0x1C, 0x02,
151	0x00, 0x1C, 0x01, 0x00, 0x00, 0x00, 0x28, 0x01, 0x01, 0x2D, 0x24, 0x06,
152	0x02, 0x04, 0x7B, 0x04, 0x75, 0x00, 0x14, 0x12, 0x2A, 0x14, 0x05, 0x04,
153	0x20, 0x01, 0x7F, 0x00, 0x2C, 0x2A, 0x14, 0x01, 0x0A, 0x0D, 0x06, 0x05,
154	0x13, 0x20, 0x01, 0x00, 0x00, 0x0D, 0x05, 0x05, 0x13, 0x2E, 0x01, 0x00,
155	0x00, 0x1E, 0x04, 0x5E, 0x00, 0x01, 0x01, 0x27, 0x06, 0x0B, 0x22, 0x01,
156	0x80, 0x7F, 0x2B, 0x14, 0x06, 0x02, 0x30, 0x00, 0x13, 0x04, 0x6E, 0x00,
157	0x2C, 0x14, 0x31, 0x05, 0x01, 0x00, 0x13, 0x04, 0x77, 0x00, 0x14, 0x14,
158	0x01, 0x80, 0x61, 0x0E, 0x1B, 0x01, 0x80, 0x7A, 0x0B, 0x10, 0x06, 0x03,
159	0x01, 0x20, 0x08, 0x00, 0x01, 0x14, 0x03, 0x00, 0x1B, 0x18, 0x05, 0x05,
160	0x20, 0x2E, 0x01, 0x00, 0x00, 0x2C, 0x14, 0x01, 0x0A, 0x0D, 0x06, 0x06,
161	0x20, 0x02, 0x00, 0x1B, 0x08, 0x00, 0x14, 0x01, 0x0D, 0x0D, 0x06, 0x03,
162	0x13, 0x04, 0x03, 0x2A, 0x18, 0x1A, 0x1E, 0x1B, 0x1F, 0x1B, 0x04, 0x59,
163	0x00, 0x19, 0x14, 0x1D, 0x05, 0x01, 0x00, 0x13, 0x11, 0x04, 0x76, 0x00,
164	0x21, 0x1A, 0x11, 0x00, 0x00, 0x2C, 0x01, 0x0A, 0x0C, 0x06, 0x02, 0x04,
165	0x78, 0x00, 0x01, 0x01, 0x7F, 0x03, 0x00, 0x2C, 0x14, 0x01, 0x0A, 0x0C,
166	0x06, 0x09, 0x31, 0x05, 0x04, 0x01, 0x00, 0x03, 0x00, 0x04, 0x70, 0x13,
167	0x02, 0x00, 0x00, 0x00, 0x14, 0x06, 0x14, 0x1F, 0x14, 0x22, 0x07, 0x17,
168	0x01, 0x2D, 0x0C, 0x06, 0x08, 0x22, 0x07, 0x1E, 0x01, 0x00, 0x1B, 0x1A,
169	0x00, 0x04, 0x69, 0x22, 0x1A, 0x00, 0x00, 0x14, 0x01, 0x0A, 0x0C, 0x1B,
170	0x01, 0x20, 0x0B, 0x10, 0x00
171};
172
173static const uint16_t t0_caddr[] = {
174	0,
175	5,
176	10,
177	15,
178	19,
179	24,
180	29,
181	67,
182	149,
183	384,
184	396,
185	431,
186	450,
187	460,
188	479,
189	523,
190	534,
191	539,
192	549,
193	574,
194	601
195};
196
197#define T0_INTERPRETED   29
198
199#define T0_ENTER(ip, rp, slot)   do { \
200		const unsigned char *t0_newip; \
201		uint32_t t0_lnum; \
202		t0_newip = &t0_codeblock[t0_caddr[(slot) - T0_INTERPRETED]]; \
203		t0_lnum = t0_parse7E_unsigned(&t0_newip); \
204		(rp) += t0_lnum; \
205		*((rp) ++) = (uint32_t)((ip) - &t0_codeblock[0]) + (t0_lnum << 16); \
206		(ip) = t0_newip; \
207	} while (0)
208
209#define T0_DEFENTRY(name, slot) \
210void \
211name(void *ctx) \
212{ \
213	t0_context *t0ctx = ctx; \
214	t0ctx->ip = &t0_codeblock[0]; \
215	T0_ENTER(t0ctx->ip, t0ctx->rp, slot); \
216}
217
218T0_DEFENTRY(br_pem_decoder_init_main, 38)
219
220#define T0_NEXT(t0ipp)   (*(*(t0ipp)) ++)
221
222void
223br_pem_decoder_run(void *t0ctx)
224{
225	uint32_t *dp, *rp;
226	const unsigned char *ip;
227
228#define T0_LOCAL(x)    (*(rp - 2 - (x)))
229#define T0_POP()       (*-- dp)
230#define T0_POPi()      (*(int32_t *)(-- dp))
231#define T0_PEEK(x)     (*(dp - 1 - (x)))
232#define T0_PEEKi(x)    (*(int32_t *)(dp - 1 - (x)))
233#define T0_PUSH(v)     do { *dp = (v); dp ++; } while (0)
234#define T0_PUSHi(v)    do { *(int32_t *)dp = (v); dp ++; } while (0)
235#define T0_RPOP()      (*-- rp)
236#define T0_RPOPi()     (*(int32_t *)(-- rp))
237#define T0_RPUSH(v)    do { *rp = (v); rp ++; } while (0)
238#define T0_RPUSHi(v)   do { *(int32_t *)rp = (v); rp ++; } while (0)
239#define T0_ROLL(x)     do { \
240	size_t t0len = (size_t)(x); \
241	uint32_t t0tmp = *(dp - 1 - t0len); \
242	memmove(dp - t0len - 1, dp - t0len, t0len * sizeof *dp); \
243	*(dp - 1) = t0tmp; \
244} while (0)
245#define T0_SWAP()      do { \
246	uint32_t t0tmp = *(dp - 2); \
247	*(dp - 2) = *(dp - 1); \
248	*(dp - 1) = t0tmp; \
249} while (0)
250#define T0_ROT()       do { \
251	uint32_t t0tmp = *(dp - 3); \
252	*(dp - 3) = *(dp - 2); \
253	*(dp - 2) = *(dp - 1); \
254	*(dp - 1) = t0tmp; \
255} while (0)
256#define T0_NROT()       do { \
257	uint32_t t0tmp = *(dp - 1); \
258	*(dp - 1) = *(dp - 2); \
259	*(dp - 2) = *(dp - 3); \
260	*(dp - 3) = t0tmp; \
261} while (0)
262#define T0_PICK(x)      do { \
263	uint32_t t0depth = (x); \
264	T0_PUSH(T0_PEEK(t0depth)); \
265} while (0)
266#define T0_CO()         do { \
267	goto t0_exit; \
268} while (0)
269#define T0_RET()        goto t0_next
270
271	dp = ((t0_context *)t0ctx)->dp;
272	rp = ((t0_context *)t0ctx)->rp;
273	ip = ((t0_context *)t0ctx)->ip;
274	goto t0_next;
275	for (;;) {
276		uint32_t t0x;
277
278	t0_next:
279		t0x = T0_NEXT(&ip);
280		if (t0x < T0_INTERPRETED) {
281			switch (t0x) {
282				int32_t t0off;
283
284			case 0: /* ret */
285				t0x = T0_RPOP();
286				rp -= (t0x >> 16);
287				t0x &= 0xFFFF;
288				if (t0x == 0) {
289					ip = NULL;
290					goto t0_exit;
291				}
292				ip = &t0_codeblock[t0x];
293				break;
294			case 1: /* literal constant */
295				T0_PUSHi(t0_parse7E_signed(&ip));
296				break;
297			case 2: /* read local */
298				T0_PUSH(T0_LOCAL(t0_parse7E_unsigned(&ip)));
299				break;
300			case 3: /* write local */
301				T0_LOCAL(t0_parse7E_unsigned(&ip)) = T0_POP();
302				break;
303			case 4: /* jump */
304				t0off = t0_parse7E_signed(&ip);
305				ip += t0off;
306				break;
307			case 5: /* jump if */
308				t0off = t0_parse7E_signed(&ip);
309				if (T0_POP()) {
310					ip += t0off;
311				}
312				break;
313			case 6: /* jump if not */
314				t0off = t0_parse7E_signed(&ip);
315				if (!T0_POP()) {
316					ip += t0off;
317				}
318				break;
319			case 7: {
320				/* + */
321
322	uint32_t b = T0_POP();
323	uint32_t a = T0_POP();
324	T0_PUSH(a + b);
325
326				}
327				break;
328			case 8: {
329				/* - */
330
331	uint32_t b = T0_POP();
332	uint32_t a = T0_POP();
333	T0_PUSH(a - b);
334
335				}
336				break;
337			case 9: {
338				/* < */
339
340	int32_t b = T0_POPi();
341	int32_t a = T0_POPi();
342	T0_PUSH(-(uint32_t)(a < b));
343
344				}
345				break;
346			case 10: {
347				/* << */
348
349	int c = (int)T0_POPi();
350	uint32_t x = T0_POP();
351	T0_PUSH(x << c);
352
353				}
354				break;
355			case 11: {
356				/* <= */
357
358	int32_t b = T0_POPi();
359	int32_t a = T0_POPi();
360	T0_PUSH(-(uint32_t)(a <= b));
361
362				}
363				break;
364			case 12: {
365				/* <> */
366
367	uint32_t b = T0_POP();
368	uint32_t a = T0_POP();
369	T0_PUSH(-(uint32_t)(a != b));
370
371				}
372				break;
373			case 13: {
374				/* = */
375
376	uint32_t b = T0_POP();
377	uint32_t a = T0_POP();
378	T0_PUSH(-(uint32_t)(a == b));
379
380				}
381				break;
382			case 14: {
383				/* >= */
384
385	int32_t b = T0_POPi();
386	int32_t a = T0_POPi();
387	T0_PUSH(-(uint32_t)(a >= b));
388
389				}
390				break;
391			case 15: {
392				/* >> */
393
394	int c = (int)T0_POPi();
395	int32_t x = T0_POPi();
396	T0_PUSHi(x >> c);
397
398				}
399				break;
400			case 16: {
401				/* and */
402
403	uint32_t b = T0_POP();
404	uint32_t a = T0_POP();
405	T0_PUSH(a & b);
406
407				}
408				break;
409			case 17: {
410				/* co */
411 T0_CO();
412				}
413				break;
414			case 18: {
415				/* data-get8 */
416
417	size_t addr = T0_POP();
418	T0_PUSH(t0_datablock[addr]);
419
420				}
421				break;
422			case 19: {
423				/* drop */
424 (void)T0_POP();
425				}
426				break;
427			case 20: {
428				/* dup */
429 T0_PUSH(T0_PEEK(0));
430				}
431				break;
432			case 21: {
433				/* flush-buf */
434
435	if (CTX->ptr > 0) {
436		if (CTX->dest) {
437			CTX->dest(CTX->dest_ctx, CTX->buf, CTX->ptr);
438		}
439		CTX->ptr = 0;
440	}
441
442				}
443				break;
444			case 22: {
445				/* from-base64 */
446
447	uint32_t c = T0_POP();
448	uint32_t p, q, r, z;
449	p = c - 0x41;
450	q = c - 0x61;
451	r = c - 0x30;
452
453	z = ((p + 2) & -LT(p, 26))
454		| ((q + 28) & -LT(q, 26))
455		| ((r + 54) & -LT(r, 10))
456		| (64 & -EQ(c, 0x2B))
457		| (65 & -EQ(c, 0x2F))
458		| EQ(c, 0x3D);
459	T0_PUSHi((int32_t)z - 2);
460
461				}
462				break;
463			case 23: {
464				/* get8 */
465
466	size_t addr = T0_POP();
467	T0_PUSH(*((unsigned char *)CTX + addr));
468
469				}
470				break;
471			case 24: {
472				/* over */
473 T0_PUSH(T0_PEEK(1));
474				}
475				break;
476			case 25: {
477				/* read8-native */
478
479	if (CTX->hlen > 0) {
480		T0_PUSH(*CTX->hbuf ++);
481		CTX->hlen --;
482	} else {
483		T0_PUSHi(-1);
484	}
485
486				}
487				break;
488			case 26: {
489				/* set8 */
490
491	size_t addr = T0_POP();
492	unsigned x = T0_POP();
493	*((unsigned char *)CTX + addr) = x;
494
495				}
496				break;
497			case 27: {
498				/* swap */
499 T0_SWAP();
500				}
501				break;
502			case 28: {
503				/* write8 */
504
505	unsigned char x = (unsigned char)T0_POP();
506	CTX->buf[CTX->ptr ++] = x;
507	if (CTX->ptr == sizeof CTX->buf) {
508		if (CTX->dest) {
509			CTX->dest(CTX->dest_ctx, CTX->buf, sizeof CTX->buf);
510		}
511		CTX->ptr = 0;
512	}
513
514				}
515				break;
516			}
517
518		} else {
519			T0_ENTER(ip, rp, t0x);
520		}
521	}
522t0_exit:
523	((t0_context *)t0ctx)->dp = dp;
524	((t0_context *)t0ctx)->rp = rp;
525	((t0_context *)t0ctx)->ip = ip;
526}
527