lib/asn1/gen_template.c

   1 /*
   2  * Copyright (c) 1997 - 2005 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Portions Copyright (c) 2009 Apple Inc. All rights reserved.
   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  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * 3. Neither the name of the Institute nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 #include "gen_locl.h"
  37
  38 static const char *symbol_name(const char *, const Type *);
  39 static void generate_template_type(const char *, const char **, const char *, const char *, const char *,
  40                                    Type *, int, int, int);
  41
  42 static const char *
  43 ttype_symbol(const char *basename, const Type *t)
  44 {
  45     return t->symbol->gen_name;
  46 }
  47
  48 static const char *
  49 integer_symbol(const char *basename, const Type *t)
  50 {
  51     if (t->members)
  52         return "int"; /* XXX enum foo */
  53     else if (t->range == NULL)
  54         return "heim_integer";
  55     else if (t->range->min == INT_MIN && t->range->max == INT_MAX)
  56         return "int";
  57     else if (t->range->min == 0 && t->range->max == UINT_MAX)
  58         return "unsigned";
  59     else if (t->range->min == 0 && t->range->max == INT_MAX)
  60         return "unsigned";
  61     else
  62         abort();
  63 }
  64
  65 static const char *
  66 boolean_symbol(const char *basename, const Type *t)
  67 {
  68     return "int";
  69 }
  70
  71
  72 static const char *
  73 octetstring_symbol(const char *basename, const Type *t)
  74 {
  75     return "heim_octet_string";
  76 }
  77
  78 static const char *
  79 sequence_symbol(const char *basename, const Type *t)
  80 {
  81     return basename;
  82 }
  83
  84 static const char *
  85 time_symbol(const char *basename, const Type *t)
  86 {
  87     return "time_t";
  88 }
  89
  90 static const char *
  91 tag_symbol(const char *basename, const Type *t)
  92 {
  93     return symbol_name(basename, t->subtype);
  94 }
  95
  96 static const char *
  97 generalstring_symbol(const char *basename, const Type *t)
  98 {
  99     return "heim_general_string";
 100 }
 101
 102 static const char *
 103 printablestring_symbol(const char *basename, const Type *t)
 104 {
 105     return "heim_printable_string";
 106 }
 107
 108 static const char *
 109 ia5string_symbol(const char *basename, const Type *t)
 110 {
 111     return "heim_ia5_string";
 112 }
 113
 114 static const char *
 115 visiblestring_symbol(const char *basename, const Type *t)
 116 {
 117     return "heim_visible_string";
 118 }
 119
 120 static const char *
 121 utf8string_symbol(const char *basename, const Type *t)
 122 {
 123     return "heim_utf8_string";
 124 }
 125
 126 static const char *
 127 bmpstring_symbol(const char *basename, const Type *t)
 128 {
 129     return "heim_bmp_string";
 130 }
 131
 132 static const char *
 133 universalstring_symbol(const char *basename, const Type *t)
 134 {
 135     return "heim_universal_string";
 136 }
 137
 138 static const char *
 139 oid_symbol(const char *basename, const Type *t)
 140 {
 141     return "heim_oid";
 142 }
 143
 144 static const char *
 145 bitstring_symbol(const char *basename, const Type *t)
 146 {
 147     if (t->members)
 148         return basename;
 149     return "heim_bit_string";
 150 }
 151
 152
 153
 154 struct {
 155     enum typetype type;
 156     const char *(*symbol_name)(const char *, const Type *);
 157     int is_struct;
 158 } types[] =  {
 159     { TBMPString, bmpstring_symbol, 0 },
 160     { TBitString, bitstring_symbol, 0 },
 161     { TBoolean, boolean_symbol, 0 },
 162     { TGeneralString, generalstring_symbol, 0 },
 163     { TGeneralizedTime, time_symbol, 0 },
 164     { TIA5String, ia5string_symbol, 0 },
 165     { TInteger, integer_symbol, 0 },
 166     { TOID, oid_symbol, 0 },
 167     { TOctetString, octetstring_symbol, 0 },
 168     { TPrintableString, printablestring_symbol, 0 },
 169     { TSequence, sequence_symbol, 1 },
 170     { TSequenceOf, tag_symbol, 1 },
 171     { TSetOf, tag_symbol, 1 },
 172     { TTag, tag_symbol, 1 },
 173     { TType, ttype_symbol, 1 },
 174     { TUTCTime, time_symbol, 0 },
 175     { TUniversalString, universalstring_symbol, 0 },
 176     { TVisibleString,  visiblestring_symbol, 0 },
 177     { TUTF8String, utf8string_symbol, 0 },
 178     { TChoice, sequence_symbol, 1 },
 179     { TNull, integer_symbol, 1 }
 180 };
 181
 182 static FILE *
 183 get_code_file(void)
 184 {
 185     if (!one_code_file)
 186         return templatefile;
 187     return codefile;
 188 }
 189
 190
 191 static int
 192 is_supported_type_p(const Type *t)
 193 {
 194     size_t i;
 195
 196     for (i = 0; i < sizeof(types)/sizeof(types[0]); i++)
 197         if (t->type == types[i].type)
 198             return 1;
 199     return 0;
 200 }
 201
 202 int
 203 is_template_compat (const Symbol *s)
 204 {
 205     return is_supported_type_p(s->type);
 206 }
 207
 208 static const char *
 209 symbol_name(const char *basename, const Type *t)
 210 {
 211     size_t i;
 212
 213     for (i = 0; i < sizeof(types)/sizeof(types[0]); i++)
 214         if (t->type == types[i].type)
 215             return (types[i].symbol_name)(basename, t);
 216     printf("unknown der type: %d\n", t->type);
 217     exit(1);
 218 }
 219
 220
 221 static char *
 222 partial_offset(const char *basetype, const char *name, int need_offset)
 223 {
 224     char *str;
 225     if (name == NULL || need_offset == 0)
 226         return strdup("0");
 227     if (asprintf(&str, "offsetof(struct %s, %s)", basetype, name) < 0 || str == NULL)
 228         errx(1, "malloc");
 229     return str;
 230 }
 231
 232 struct template {
 233     char *line;
 234     char *tt;
 235     char *offset;
 236     char *ptr;
 237     ASN1_TAILQ_ENTRY(template) members;
 238 };
 239
 240 ASN1_TAILQ_HEAD(templatehead, template);
 241
 242 struct tlist {
 243     char *name;
 244     char *header;
 245     struct templatehead template;
 246     ASN1_TAILQ_ENTRY(tlist) tmembers;
 247 };
 248
 249 ASN1_TAILQ_HEAD(tlisthead, tlist);
 250
 251 static void tlist_header(struct tlist *, const char *, ...) __attribute__((__format__(__printf__, 2, 3)));
 252 static struct template *
 253     add_line(struct templatehead *, const char *, ...) __attribute__((__format__(__printf__, 2, 3)));
 254 static int tlist_cmp(const struct tlist *, const struct tlist *);
 255
 256 static void add_line_pointer(struct templatehead *, const char *, const char *, const char *, ...)
 257     __attribute__((__format__(__printf__, 4, 5)));
 258
 259
 260 static struct tlisthead tlistmaster = ASN1_TAILQ_HEAD_INITIALIZER(tlistmaster);
 261 static unsigned long numdups = 0;
 262
 263 static struct tlist *
 264 tlist_new(const char *name)
 265 {
 266     struct tlist *tl = calloc(1, sizeof(*tl));
 267     tl->name = strdup(name);
 268     ASN1_TAILQ_INIT(&tl->template);
 269     return tl;
 270 }
 271
 272 static void
 273 tlist_header(struct tlist *t, const char *fmt, ...)
 274 {
 275     va_list ap;
 276     va_start(ap, fmt);
 277     if (vasprintf(&t->header, fmt, ap) < 0 || t->header == NULL)
 278         errx(1, "malloc");
 279     va_end(ap);
 280 }
 281
 282 static unsigned long
 283 tlist_count(struct tlist *tl)
 284 {
 285     unsigned int count = 0;
 286     struct template *q;
 287
 288     ASN1_TAILQ_FOREACH(q, &tl->template, members) {
 289         count++;
 290     }
 291     return count;
 292 }
 293
 294 static void
 295 tlist_add(struct tlist *tl)
 296 {
 297     ASN1_TAILQ_INSERT_TAIL(&tlistmaster, tl, tmembers);
 298 }
 299
 300 static void
 301 tlist_print(struct tlist *tl)
 302 {
 303     struct template *q;
 304     unsigned int i = 1;
 305     FILE *f = get_code_file();
 306
 307     fprintf(f, "static const struct asn1_template asn1_%s[] = {\n", tl->name);
 308     fprintf(f, "/* 0 */ %s,\n", tl->header);
 309     ASN1_TAILQ_FOREACH(q, &tl->template, members) {
 310         int last = (ASN1_TAILQ_LAST(&tl->template, templatehead) == q);
 311         fprintf(f, "/* %lu */ %s%s\n", (unsigned long)i++, q->line, last ? "" : ",");
 312     }
 313     fprintf(f, "};\n");
 314 }
 315
 316 static struct tlist *
 317 tlist_find_by_name(const char *name)
 318 {
 319     struct tlist *ql;
 320     ASN1_TAILQ_FOREACH(ql, &tlistmaster, tmembers) {
 321         if (strcmp(ql->name, name) == 0)
 322             return ql;
 323     }
 324     return NULL;
 325 }
 326
 327 static int
 328 tlist_cmp_name(const char *tname, const char *qname)
 329 {
 330     struct tlist *tl = tlist_find_by_name(tname);
 331     struct tlist *ql = tlist_find_by_name(qname);
 332     return tlist_cmp(tl, ql);
 333 }
 334
 335 static int
 336 tlist_cmp(const struct tlist *tl, const struct tlist *ql)
 337 {
 338     int ret;
 339     struct template *t, *q;
 340
 341     ret = strcmp(tl->header, ql->header);
 342     if (ret) return ret;
 343
 344     q = ASN1_TAILQ_FIRST(&ql->template);
 345     ASN1_TAILQ_FOREACH(t, &tl->template, members) {
 346         if (q == NULL) return 1;
 347
 348         if (t->ptr == NULL || q->ptr == NULL) {
 349             ret = strcmp(t->line, q->line);
 350             if (ret) return ret;
 351         } else {
 352             ret = strcmp(t->tt, q->tt);
 353             if (ret) return ret;
 354
 355             ret = strcmp(t->offset, q->offset);
 356             if (ret) return ret;
 357
 358             if ((ret = strcmp(t->ptr, q->ptr)) != 0 ||
 359                 (ret = tlist_cmp_name(t->ptr, q->ptr)) != 0)
 360                 return ret;
 361         }
 362         q = ASN1_TAILQ_NEXT(q, members);
 363     }
 364     if (q != NULL) return -1;
 365     return 0;
 366 }
 367
 368
 369 static const char *
 370 tlist_find_dup(const struct tlist *tl)
 371 {
 372     struct tlist *ql;
 373
 374     ASN1_TAILQ_FOREACH(ql, &tlistmaster, tmembers) {
 375         if (tlist_cmp(ql, tl) == 0) {
 376             numdups++;
 377             return ql->name;
 378         }
 379     }
 380     return NULL;
 381 }
 382
 383
 384 /*
 385  *
 386  */
 387
 388 static struct template *
 389 add_line(struct templatehead *t, const char *fmt, ...)
 390 {
 391     struct template *q = calloc(1, sizeof(*q));
 392     va_list ap;
 393     va_start(ap, fmt);
 394     if (vasprintf(&q->line, fmt, ap) < 0 || q->line == NULL)
 395         errx(1, "malloc");
 396     va_end(ap);
 397     ASN1_TAILQ_INSERT_TAIL(t, q, members);
 398     return q;
 399 }
 400
 401 static void
 402 add_line_pointer(struct templatehead *t,
 403                  const char *ptr,
 404                  const char *offset,
 405                  const char *ttfmt,
 406                  ...)
 407 {
 408     struct template *q;
 409     va_list ap;
 410     char *tt = NULL;
 411
 412     va_start(ap, ttfmt);
 413     if (vasprintf(&tt, ttfmt, ap) < 0 || tt == NULL)
 414         errx(1, "malloc");
 415     va_end(ap);
 416
 417     q = add_line(t, "{ %s, %s, asn1_%s }", tt, offset, ptr);
 418     q->tt = tt;
 419     q->offset = strdup(offset);
 420     q->ptr = strdup(ptr);
 421 }
 422
 423 static int
 424 use_extern(const Symbol *s)
 425 {
 426     if (s->type == NULL)
 427         return 1;
 428     return 0;
 429 }
 430
 431 static int
 432 is_struct(Type *t, int isstruct)
 433 {
 434     size_t i;
 435
 436     if (t->type == TType)
 437         return 0;
 438     if (t->type == TSequence || t->type == TSet || t->type == TChoice)
 439         return 1;
 440     if (t->type == TTag)
 441         return is_struct(t->subtype, isstruct);
 442
 443     for (i = 0; i < sizeof(types)/sizeof(types[0]); i++) {
 444         if (t->type == types[i].type) {
 445             if (types[i].is_struct == 0)
 446                 return 0;
 447             else
 448                 break;
 449         }
 450     }
 451
 452     return isstruct;
 453 }
 454
 455 static const Type *
 456 compact_tag(const Type *t)
 457 {
 458     while (t->type == TTag)
 459         t = t->subtype;
 460     return t;
 461 }
 462
 463 static void
 464 template_members(struct templatehead *temp, const char *basetype, const char *name, const Type *t, int optional, int isstruct, int need_offset)
 465 {
 466     char *poffset = NULL;
 467
 468     if (optional && t->type != TTag && t->type != TType)
 469         errx(1, "%s...%s is optional and not a (TTag or TType)", basetype, name);
 470
 471     poffset = partial_offset(basetype, name, need_offset);
 472
 473     switch (t->type) {
 474     case TType:
 475         if (use_extern(t->symbol)) {
 476             add_line(temp, "{ A1_OP_TYPE_EXTERN %s, %s, &asn1_extern_%s}",
 477                      optional ? "|A1_FLAG_OPTIONAL" : "",
 478                      poffset, t->symbol->gen_name);
 479         } else {
 480             add_line_pointer(temp, t->symbol->gen_name, poffset,
 481                              "A1_OP_TYPE %s", optional ? "|A1_FLAG_OPTIONAL" : "");
 482         }
 483         break;
 484     case TInteger: {
 485         char *itype;
 486
 487         if (t->members)
 488             itype = "IMEMBER";
 489         else if (t->range == NULL)
 490             itype = "HEIM_INTEGER";
 491         else if (t->range->min == INT_MIN && t->range->max == INT_MAX)
 492             itype = "INTEGER";
 493         else if (t->range->min == 0 && t->range->max == UINT_MAX)
 494             itype = "UNSIGNED";
 495         else if (t->range->min == 0 && t->range->max == INT_MAX)
 496             itype = "UNSIGNED";
 497         else
 498             errx(1, "%s: unsupported range %d -> %d",
 499                  name, t->range->min, t->range->max);
 500
 501         add_line(temp, "{ A1_PARSE_T(A1T_%s), %s, NULL }", itype, poffset);
 502         break;
 503     }
 504     case TGeneralString:
 505         add_line(temp, "{ A1_PARSE_T(A1T_GENERAL_STRING), %s, NULL }", poffset);
 506         break;
 507     case TTeletexString:
 508         add_line(temp, "{ A1_PARSE_T(A1T_TELETEX_STRING), %s, NULL }", poffset);
 509         break;
 510     case TPrintableString:
 511         add_line(temp, "{ A1_PARSE_T(A1T_PRINTABLE_STRING), %s, NULL }", poffset);
 512         break;
 513     case TOctetString:
 514         add_line(temp, "{ A1_PARSE_T(A1T_OCTET_STRING), %s, NULL }", poffset);
 515         break;
 516     case TIA5String:
 517         add_line(temp, "{ A1_PARSE_T(A1T_IA5_STRING), %s, NULL }", poffset);
 518         break;
 519     case TBMPString:
 520         add_line(temp, "{ A1_PARSE_T(A1T_BMP_STRING), %s, NULL }", poffset);
 521         break;
 522     case TUniversalString:
 523         add_line(temp, "{ A1_PARSE_T(A1T_UNIVERSAL_STRING), %s, NULL }", poffset);
 524         break;
 525     case TVisibleString:
 526         add_line(temp, "{ A1_PARSE_T(A1T_VISIBLE_STRING), %s, NULL }", poffset);
 527         break;
 528     case TUTF8String:
 529         add_line(temp, "{ A1_PARSE_T(A1T_UTF8_STRING), %s, NULL }", poffset);
 530         break;
 531     case TGeneralizedTime:
 532         add_line(temp, "{ A1_PARSE_T(A1T_GENERALIZED_TIME), %s, NULL }", poffset);
 533         break;
 534     case TUTCTime:
 535         add_line(temp, "{ A1_PARSE_T(A1T_UTC_TIME), %s, NULL }", poffset);
 536         break;
 537     case TBoolean:
 538         add_line(temp, "{ A1_PARSE_T(A1T_BOOLEAN), %s, NULL }", poffset);
 539         break;
 540     case TOID:
 541         add_line(temp, "{ A1_PARSE_T(A1T_OID), %s, NULL }", poffset);
 542         break;
 543     case TNull:
 544         break;
 545     case TBitString: {
 546         struct templatehead template = ASN1_TAILQ_HEAD_INITIALIZER(template);
 547         struct template *q;
 548         Member *m;
 549         size_t count = 0, i;
 550         char *bname = NULL;
 551         FILE *f = get_code_file();
 552
 553         if (ASN1_TAILQ_EMPTY(t->members)) {
 554             add_line(temp, "{ A1_PARSE_T(A1T_HEIM_BIT_STRING), %s, NULL }", poffset);
 555             break;
 556         }
 557
 558         if (asprintf(&bname, "bmember_%s_%lu", name ? name : "", (unsigned long)t) < 0 || bname == NULL)
 559             errx(1, "malloc");
 560         output_name(bname);
 561
 562         ASN1_TAILQ_FOREACH(m, t->members, members) {
 563             add_line(&template, "{ 0, %d, 0 } /* %s */", m->val, m->gen_name);
 564         }
 565
 566         ASN1_TAILQ_FOREACH(q, &template, members) {
 567             count++;
 568         }
 569
 570         fprintf(f, "static const struct asn1_template asn1_%s_%s[] = {\n", basetype, bname);
 571         fprintf(f, "/* 0 */ { 0%s, sizeof(%s), ((void *)%lu) },\n",
 572                 rfc1510_bitstring ? "|A1_HBF_RFC1510" : "",
 573                 basetype, (unsigned long)count);
 574         i = 1;
 575         ASN1_TAILQ_FOREACH(q, &template, members) {
 576             int last = (ASN1_TAILQ_LAST(&template, templatehead) == q);
 577             fprintf(f, "/* %lu */ %s%s\n", (unsigned long)i++, q->line, last ? "" : ",");
 578         }
 579         fprintf(f, "};\n");
 580
 581         add_line(temp, "{ A1_OP_BMEMBER, %s, asn1_%s_%s }", poffset, basetype, bname);
 582
 583         free(bname);
 584
 585         break;
 586     }
 587     case TSequence: {
 588         Member *m;
 589
 590         ASN1_TAILQ_FOREACH(m, t->members, members) {
 591             char *newbasename = NULL;
 592
 593             if (m->ellipsis)
 594                 continue;
 595
 596             if (name) {
 597                 if (asprintf(&newbasename, "%s_%s", basetype, name) < 0)
 598                     errx(1, "malloc");
 599             } else
 600                 newbasename = strdup(basetype);
 601             if (newbasename == NULL)
 602                 errx(1, "malloc");
 603
 604             template_members(temp, newbasename, m->gen_name, m->type, m->optional, isstruct, 1);
 605
 606             free(newbasename);
 607         }
 608
 609         break;
 610     }
 611     case TTag: {
 612         char *tname = NULL, *elname = NULL;
 613         const char *sename, *dupname;
 614         int subtype_is_struct = is_struct(t->subtype, isstruct);
 615
 616         if (subtype_is_struct)
 617             sename = basetype;
 618         else
 619             sename = symbol_name(basetype, t->subtype);
 620
 621         if (asprintf(&tname, "tag_%s_%lu", name ? name : "", (unsigned long)t) < 0 || tname == NULL)
 622             errx(1, "malloc");
 623         output_name(tname);
 624
 625         if (asprintf(&elname, "%s_%s", basetype, tname) < 0 || elname == NULL)
 626             errx(1, "malloc");
 627
 628         generate_template_type(elname, &dupname, NULL, sename, name,
 629                                t->subtype, 0, subtype_is_struct, 0);
 630
 631         add_line_pointer(temp, dupname, poffset,
 632                          "A1_TAG_T(%s,%s,%s)%s",
 633                          classname(t->tag.tagclass),
 634                          is_primitive_type(t->subtype->type)  ? "PRIM" : "CONS",
 635                          valuename(t->tag.tagclass, t->tag.tagvalue),
 636                          optional ? "|A1_FLAG_OPTIONAL" : "");
 637
 638         free(tname);
 639         free(elname);
 640
 641         break;
 642     }
 643     case TSetOf:
 644     case TSequenceOf: {
 645         const char *type, *tname, *dupname;
 646         char *sename = NULL, *elname = NULL;
 647         int subtype_is_struct = is_struct(t->subtype, 0);
 648
 649         if (name && subtype_is_struct) {
 650             tname = "seofTstruct";
 651             if (asprintf(&sename, "%s_%s_val", basetype, name) < 0)
 652                 errx(1, "malloc");
 653         } else if (subtype_is_struct) {
 654             tname = "seofTstruct";
 655             if (asprintf(&sename, "%s_val", symbol_name(basetype, t->subtype)) < 0)
 656                 errx(1, "malloc");
 657         } else {
 658             if (name)
 659                 tname = name;
 660             else
 661                 tname = "seofTstruct";
 662             sename = strdup(symbol_name(basetype, t->subtype));
 663         }
 664         if (sename == NULL)
 665             errx(1, "malloc");
 666
 667         if (t->type == TSetOf) type = "A1_OP_SETOF";
 668         else if (t->type == TSequenceOf) type = "A1_OP_SEQOF";
 669         else abort();
 670
 671         if (asprintf(&elname, "%s_%s_%lu", basetype, tname, (unsigned long)t) < 0 || elname == NULL)
 672             errx(1, "malloc");
 673
 674         generate_template_type(elname, &dupname, NULL, sename, NULL, t->subtype,
 675                                0, subtype_is_struct, need_offset);
 676
 677         add_line(temp, "{ %s, %s, asn1_%s }", type, poffset, dupname);
 678         free(sename);
 679         break;
 680     }
 681     case TChoice: {
 682         struct templatehead template = ASN1_TAILQ_HEAD_INITIALIZER(template);
 683         struct template *q;
 684         size_t count = 0, i;
 685         char *tname = NULL;
 686         FILE *f = get_code_file();
 687         Member *m;
 688         int ellipsis = 0;
 689         char *e;
 690
 691         if (asprintf(&tname, "asn1_choice_%s_%s%x",
 692                      basetype, name ? name : "", (unsigned int)(uintptr_t)t) < 0 || tname == NULL)
 693             errx(1, "malloc");
 694
 695         ASN1_TAILQ_FOREACH(m, t->members, members) {
 696             const char *dupname;
 697             char *elname = NULL;
 698             char *newbasename = NULL;
 699             int subtype_is_struct;
 700
 701             if (m->ellipsis) {
 702                 ellipsis = 1;
 703                 continue;
 704             }
 705
 706             subtype_is_struct = is_struct(m->type, 0);
 707
 708             if (asprintf(&elname, "%s_choice_%s", basetype, m->gen_name) < 0 || elname == NULL)
 709                 errx(1, "malloc");
 710
 711             if (subtype_is_struct) {
 712                 if (asprintf(&newbasename, "%s_%s", basetype, m->gen_name) < 0)
 713                     errx(1, "malloc");
 714             } else
 715                 newbasename = strdup(basetype);
 716
 717             if (newbasename == NULL)
 718                 errx(1, "malloc");
 719
 720
 721             generate_template_type(elname, &dupname, NULL,
 722                                    symbol_name(newbasename, m->type),
 723                                    NULL, m->type, 0, subtype_is_struct, 1);
 724
 725             add_line(&template, "{ %s, offsetof(%s%s, u.%s), asn1_%s }",
 726                      m->label, isstruct ? "struct " : "",
 727                      basetype, m->gen_name,
 728                      dupname);
 729
 730             free(elname);
 731             free(newbasename);
 732         }
 733
 734         e = NULL;
 735         if (ellipsis) {
 736             if (asprintf(&e, "offsetof(%s%s, u.asn1_ellipsis)", isstruct ? "struct " : "", basetype) < 0 || e == NULL)
 737                 errx(1, "malloc");
 738         }
 739
 740         ASN1_TAILQ_FOREACH(q, &template, members) {
 741             count++;
 742         }
 743
 744         fprintf(f, "static const struct asn1_template %s[] = {\n", tname);
 745         fprintf(f, "/* 0 */ { %s, offsetof(%s%s, element), ((void *)%lu) },\n",
 746                 e ? e : "0", isstruct ? "struct " : "", basetype, (unsigned long)count);
 747         i = 1;
 748         ASN1_TAILQ_FOREACH(q, &template, members) {
 749             int last = (ASN1_TAILQ_LAST(&template, templatehead) == q);
 750             fprintf(f, "/* %lu */ %s%s\n", (unsigned long)i++, q->line, last ? "" : ",");
 751         }
 752         fprintf(f, "};\n");
 753
 754         add_line(temp, "{ A1_OP_CHOICE, %s, %s }", poffset, tname);
 755
 756         free(e);
 757         free(tname);
 758         break;
 759     }
 760     default:
 761         abort ();
 762     }
 763     if (poffset)
 764         free(poffset);
 765 }
 766
 767 static void
 768 gen_extern_stubs(FILE *f, const char *name)
 769 {
 770     fprintf(f,
 771             "static const struct asn1_type_func asn1_extern_%s = {\n"
 772             "\t(asn1_type_encode)encode_%s,\n"
 773             "\t(asn1_type_decode)decode_%s,\n"
 774             "\t(asn1_type_length)length_%s,\n"
 775             "\t(asn1_type_copy)copy_%s,\n"
 776             "\t(asn1_type_release)free_%s,\n"
 777             "\tsizeof(%s)\n"
 778             "};\n",
 779             name, name, name, name,
 780             name, name, name);
 781 }
 782
 783 void
 784 gen_template_import(const Symbol *s)
 785 {
 786     FILE *f = get_code_file();
 787
 788     if (template_flag == 0)
 789         return;
 790
 791     gen_extern_stubs(f, s->gen_name);
 792 }
 793
 794 static void
 795 generate_template_type(const char *varname,
 796                        const char **dupname,
 797                        const char *symname,
 798                        const char *basetype,
 799                        const char *name,
 800                        Type *type,
 801                        int optional, int isstruct, int need_offset)
 802 {
 803     struct tlist *tl;
 804     const char *dup;
 805     int have_ellipsis = 0;
 806
 807     tl = tlist_new(varname);
 808
 809     template_members(&tl->template, basetype, name, type, optional, isstruct, need_offset);
 810
 811     /* if its a sequence or set type, check if there is a ellipsis */
 812     if (type->type == TSequence || type->type == TSet) {
 813         Member *m;
 814         ASN1_TAILQ_FOREACH(m, type->members, members) {
 815             if (m->ellipsis)
 816                 have_ellipsis = 1;
 817         }
 818     }
 819
 820     if (ASN1_TAILQ_EMPTY(&tl->template) && compact_tag(type)->type != TNull)
 821         errx(1, "Tag %s...%s with no content ?", basetype, name ? name : "");
 822
 823     tlist_header(tl, "{ 0%s%s, sizeof(%s%s), ((void *)%lu) }",
 824                  (symname && preserve_type(symname)) ? "|A1_HF_PRESERVE" : "",
 825                  have_ellipsis ? "|A1_HF_ELLIPSIS" : "",
 826                  isstruct ? "struct " : "", basetype, tlist_count(tl));
 827
 828     dup = tlist_find_dup(tl);
 829     if (dup) {
 830         if (strcmp(dup, tl->name) == 0)
 831             errx(1, "found dup of ourself");
 832         *dupname = dup;
 833     } else {
 834         *dupname = tl->name;
 835         tlist_print(tl);
 836         tlist_add(tl);
 837     }
 838 }
 839
 840
 841 void
 842 generate_template(const Symbol *s)
 843 {
 844     FILE *f = get_code_file();
 845     const char *dupname;
 846
 847     if (use_extern(s)) {
 848         gen_extern_stubs(f, s->gen_name);
 849         return;
 850     }
 851
 852     generate_template_type(s->gen_name, &dupname, s->name, s->gen_name, NULL, s->type, 0, 0, 1);
 853
 854     fprintf(f,
 855             "\n"
 856             "int\n"
 857             "decode_%s(const unsigned char *p, size_t len, %s *data, size_t *size)\n"
 858             "{\n"
 859             "    return _asn1_decode_top(asn1_%s, 0|%s, p, len, data, size);\n"
 860             "}\n"
 861             "\n",
 862             s->gen_name,
 863             s->gen_name,
 864             dupname,
 865             support_ber ? "A1_PF_ALLOW_BER" : "0");
 866
 867     fprintf(f,
 868             "\n"
 869             "int\n"
 870             "encode_%s(unsigned char *p, size_t len, const %s *data, size_t *size)\n"
 871             "{\n"
 872             "    return _asn1_encode(asn1_%s, p, len, data, size);\n"
 873             "}\n"
 874             "\n",
 875             s->gen_name,
 876             s->gen_name,
 877             dupname);
 878
 879     fprintf(f,
 880             "\n"
 881             "size_t\n"
 882             "length_%s(const %s *data)\n"
 883             "{\n"
 884             "    return _asn1_length(asn1_%s, data);\n"
 885             "}\n"
 886             "\n",
 887             s->gen_name,
 888             s->gen_name,
 889             dupname);
 890
 891
 892     fprintf(f,
 893             "\n"
 894             "void\n"
 895             "free_%s(%s *data)\n"
 896             "{\n"
 897             "    _asn1_free(asn1_%s, data);\n"
 898             "}\n"
 899             "\n",
 900             s->gen_name,
 901             s->gen_name,
 902             dupname);
 903
 904     fprintf(f,
 905             "\n"
 906             "int\n"
 907             "copy_%s(const %s *from, %s *to)\n"
 908             "{\n"
 909             "    return _asn1_copy_top(asn1_%s, from, to);\n"
 910             "}\n"
 911             "\n",
 912             s->gen_name,
 913             s->gen_name,
 914             s->gen_name,
 915             dupname);
 916 }