crypto/external/bsd/heimdal/dist/lib/asn1/gen_template.c

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