contrib/bearssl/src/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 unsigned char 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 *)(void *)((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 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
 117 static 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
 173 static 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) \
 210 void \
 211 name(void *ctx) \
 212 { \
 213         t0_context *t0ctx = ctx; \
 214         t0ctx->ip = &t0_codeblock[0]; \
 215         T0_ENTER(t0ctx->ip, t0ctx->rp, slot); \
 216 }
 217
 218 T0_DEFENTRY(br_pem_decoder_init_main, 38)
 219
 220 #define T0_NEXT(t0ipp)   (*(*(t0ipp)) ++)
 221
 222 void
 223 br_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         }
 522 t0_exit:
 523         ((t0_context *)t0ctx)->dp = dp;
 524         ((t0_context *)t0ctx)->rp = rp;
 525         ((t0_context *)t0ctx)->ip = ip;
 526 }