lib/asn1/gen.c

   1 /*
   2  * Copyright (c) 1997 - 2005 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include "gen_locl.h"
  35
  36 RCSID("$Id$");
  37
  38 FILE *headerfile, *codefile, *logfile;
  39
  40 #define STEM "asn1"
  41
  42 static const char *orig_filename;
  43 static char *header;
  44 static const char *headerbase = STEM;
  45
  46 /*
  47  * list of all IMPORTs
  48  */
  49
  50 struct import {
  51     const char *module;
  52     struct import *next;
  53 };
  54
  55 static struct import *imports = NULL;
  56
  57 void
  58 add_import (const char *module)
  59 {
  60     struct import *tmp = emalloc (sizeof(*tmp));
  61
  62     tmp->module = module;
  63     tmp->next   = imports;
  64     imports     = tmp;
  65
  66     fprintf (headerfile, "#include <%s_asn1.h>\n", module);
  67 }
  68
  69 const char *
  70 get_filename (void)
  71 {
  72     return orig_filename;
  73 }
  74
  75 void
  76 init_generate (const char *filename, const char *base)
  77 {
  78     char *fn;
  79
  80     orig_filename = filename;
  81     if (base != NULL) {
  82         headerbase = strdup(base);
  83         if (headerbase == NULL)
  84             errx(1, "strdup");
  85     }
  86     asprintf(&header, "%s.hx", headerbase);
  87     if (header == NULL)
  88         errx(1, "malloc");
  89     headerfile = fopen (header, "w");
  90     if (headerfile == NULL)
  91         err (1, "open %s", header);
  92     fprintf (headerfile,
  93              "/* Generated from %s */\n"
  94              "/* Do not edit */\n\n",
  95              filename);
  96     fprintf (headerfile,
  97              "#ifndef __%s_h__\n"
  98              "#define __%s_h__\n\n", headerbase, headerbase);
  99     fprintf (headerfile,
 100              "#include <stddef.h>\n"
 101              "#include <time.h>\n\n");
 102     fprintf (headerfile,
 103              "#ifndef __asn1_common_definitions__\n"
 104              "#define __asn1_common_definitions__\n\n");
 105     fprintf (headerfile,
 106              "typedef struct heim_integer {\n"
 107              "  size_t length;\n"
 108              "  void *data;\n"
 109              "  int negative;\n"
 110              "} heim_integer;\n\n");
 111     fprintf (headerfile,
 112              "typedef struct heim_octet_string {\n"
 113              "  size_t length;\n"
 114              "  void *data;\n"
 115              "} heim_octet_string;\n\n");
 116     fprintf (headerfile,
 117              "typedef char *heim_general_string;\n\n"
 118              );
 119     fprintf (headerfile,
 120              "typedef char *heim_utf8_string;\n\n"
 121              );
 122     fprintf (headerfile,
 123              "typedef char *heim_printable_string;\n\n"
 124              );
 125     fprintf (headerfile,
 126              "typedef char *heim_ia5_string;\n\n"
 127              );
 128     fprintf (headerfile,
 129              "typedef struct heim_bmp_string {\n"
 130              "  size_t length;\n"
 131              "  uint16_t *data;\n"
 132              "} heim_bmp_string;\n\n");
 133     fprintf (headerfile,
 134              "typedef struct heim_universal_string {\n"
 135              "  size_t length;\n"
 136              "  uint32_t *data;\n"
 137              "} heim_universal_string;\n\n");
 138     fprintf (headerfile,
 139              "typedef char *heim_visible_string;\n\n"
 140              );
 141     fprintf (headerfile,
 142              "typedef struct heim_oid {\n"
 143              "  size_t length;\n"
 144              "  unsigned *components;\n"
 145              "} heim_oid;\n\n");
 146     fprintf (headerfile,
 147              "typedef struct heim_bit_string {\n"
 148              "  size_t length;\n"
 149              "  void *data;\n"
 150              "} heim_bit_string;\n\n");
 151     fprintf (headerfile,
 152              "typedef struct heim_octet_string heim_any;\n"
 153              "typedef struct heim_octet_string heim_any_set;\n\n");
 154     fputs("#define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R)                  \\\n"
 155           "  do {                                                         \\\n"
 156           "    (BL) = length_##T((S));                                    \\\n"
 157           "    (B) = malloc((BL));                                        \\\n"
 158           "    if((B) == NULL) {                                          \\\n"
 159           "      (R) = ENOMEM;                                            \\\n"
 160           "    } else {                                                   \\\n"
 161           "      (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \\\n"
 162           "                       (S), (L));                              \\\n"
 163           "      if((R) != 0) {                                           \\\n"
 164           "        free((B));                                             \\\n"
 165           "        (B) = NULL;                                            \\\n"
 166           "      }                                                        \\\n"
 167           "    }                                                          \\\n"
 168           "  } while (0)\n\n",
 169           headerfile);
 170     fprintf (headerfile, "struct units;\n\n");
 171     fprintf (headerfile, "#endif\n\n");
 172     asprintf(&fn, "%s_files", base);
 173     if (fn == NULL)
 174         errx(1, "malloc");
 175     logfile = fopen(fn, "w");
 176     if (logfile == NULL)
 177         err (1, "open %s", fn);
 178 }
 179
 180 void
 181 close_generate (void)
 182 {
 183     fprintf (headerfile, "#endif /* __%s_h__ */\n", headerbase);
 184
 185     fclose (headerfile);
 186     fprintf (logfile, "\n");
 187     fclose (logfile);
 188 }
 189
 190 void
 191 gen_assign_defval(const char *var, struct value *val)
 192 {
 193     switch(val->type) {
 194     case stringvalue:
 195         fprintf(codefile, "if((%s = strdup(\"%s\")) == NULL)\nreturn ENOMEM;\n", var, val->u.stringvalue);
 196         break;
 197     case integervalue:
 198         fprintf(codefile, "%s = %d;\n", var, val->u.integervalue);
 199         break;
 200     case booleanvalue:
 201         if(val->u.booleanvalue)
 202             fprintf(codefile, "%s = TRUE;\n", var);
 203         else
 204             fprintf(codefile, "%s = FALSE;\n", var);
 205         break;
 206     default:
 207         abort();
 208     }
 209 }
 210
 211 void
 212 gen_compare_defval(const char *var, struct value *val)
 213 {
 214     switch(val->type) {
 215     case stringvalue:
 216         fprintf(codefile, "if(strcmp(%s, \"%s\") != 0)\n", var, val->u.stringvalue);
 217         break;
 218     case integervalue:
 219         fprintf(codefile, "if(%s != %d)\n", var, val->u.integervalue);
 220         break;
 221     case booleanvalue:
 222         if(val->u.booleanvalue)
 223             fprintf(codefile, "if(!%s)\n", var);
 224         else
 225             fprintf(codefile, "if(%s)\n", var);
 226         break;
 227     default:
 228         abort();
 229     }
 230 }
 231
 232 void
 233 generate_header_of_codefile(const char *name)
 234 {
 235     char *filename;
 236
 237     if (codefile != NULL)
 238         abort();
 239
 240     asprintf (&filename, "%s_%s.x", STEM, name);
 241     if (filename == NULL)
 242         errx(1, "malloc");
 243     codefile = fopen (filename, "w");
 244     if (codefile == NULL)
 245         err (1, "fopen %s", filename);
 246     fprintf(logfile, "%s ", filename);
 247     free(filename);
 248     fprintf (codefile,
 249              "/* Generated from %s */\n"
 250              "/* Do not edit */\n\n"
 251              "#include <stdio.h>\n"
 252              "#include <stdlib.h>\n"
 253              "#include <time.h>\n"
 254              "#include <string.h>\n"
 255              "#include <errno.h>\n"
 256              "#include <limits.h>\n"
 257              "#include <krb5-types.h>\n",
 258              orig_filename);
 259
 260     fprintf (codefile,
 261              "#include <%s.h>\n",
 262              headerbase);
 263     fprintf (codefile,
 264              "#include <asn1_err.h>\n"
 265              "#include <der.h>\n"
 266              "#include <parse_units.h>\n\n");
 267
 268 }
 269
 270 void
 271 close_codefile(void)
 272 {
 273     if (codefile == NULL)
 274         abort();
 275
 276     fclose(codefile);
 277     codefile = NULL;
 278 }
 279
 280
 281 void
 282 generate_constant (const Symbol *s)
 283 {
 284     switch(s->value->type) {
 285     case booleanvalue:
 286         break;
 287     case integervalue:
 288         fprintf (headerfile, "enum { %s = %d };\n\n",
 289                  s->gen_name, s->value->u.integervalue);
 290         break;
 291     case nullvalue:
 292         break;
 293     case stringvalue:
 294         break;
 295     case objectidentifiervalue: {
 296         struct objid *o, **list;
 297         unsigned int i, len;
 298
 299         if (!one_code_file)
 300             generate_header_of_codefile(s->gen_name);
 301
 302         len = 0;
 303         for (o = s->value->u.objectidentifiervalue; o != NULL; o = o->next)
 304             len++;
 305         if (len == 0) {
 306             printf("s->gen_name: %s",s->gen_name);
 307             fflush(stdout);
 308             break;
 309         }
 310         list = emalloc(sizeof(*list) * len);
 311
 312         i = 0;
 313         for (o = s->value->u.objectidentifiervalue; o != NULL; o = o->next)
 314             list[i++] = o;
 315
 316         fprintf (headerfile, "/* OBJECT IDENTIFIER %s ::= { ", s->name);
 317         for (i = len ; i > 0; i--) {
 318             o = list[i - 1];
 319             fprintf(headerfile, "%s(%d) ",
 320                     o->label ? o->label : "label-less", o->value);
 321         }
 322
 323         fprintf (headerfile, "} */\n");
 324         fprintf (headerfile, "const heim_oid *oid_%s(void);\n",
 325                  s->gen_name);
 326         fprintf (headerfile,
 327                  "extern const heim_oid asn1_oid_%s;\n\n",
 328                  s->gen_name);
 329
 330
 331         fprintf (codefile, "static unsigned oid_%s_variable_num[%d] =  {",
 332                  s->gen_name, len);
 333         for (i = len ; i > 0; i--) {
 334             fprintf(codefile, "%d%s ", list[i - 1]->value, i > 1 ? "," : "");
 335         }
 336         fprintf(codefile, "};\n");
 337
 338         fprintf (codefile, "const heim_oid asn1_oid_%s = "
 339                  "{ %d, oid_%s_variable_num };\n\n",
 340                  s->gen_name, len, s->gen_name);
 341
 342         fprintf (codefile, "const heim_oid *oid_%s(void)\n"
 343                  "{\n"
 344                  "return &asn1_oid_%s;\n"
 345                  "}\n\n",
 346                  s->gen_name, s->gen_name);
 347
 348         free(list);
 349
 350         if (!one_code_file)
 351             close_codefile();
 352
 353         break;
 354     }
 355     default:
 356         abort();
 357     }
 358 }
 359
 360 static void
 361 space(int level)
 362 {
 363     while(level-- > 0)
 364         fprintf(headerfile, "  ");
 365 }
 366
 367 static const char *
 368 last_member_p(struct member *m)
 369 {
 370     struct member *n = ASN1_TAILQ_NEXT(m, members);
 371     if (n == NULL)
 372         return "";
 373     if (n->ellipsis && ASN1_TAILQ_NEXT(n, members) == NULL)
 374         return "";
 375     return ",";
 376 }
 377
 378 static struct member *
 379 have_ellipsis(Type *t)
 380 {
 381     struct member *m;
 382     ASN1_TAILQ_FOREACH(m, t->members, members) {
 383         if (m->ellipsis)
 384             return m;
 385     }
 386     return NULL;
 387 }
 388
 389 static void
 390 define_asn1 (int level, Type *t)
 391 {
 392     switch (t->type) {
 393     case TType:
 394         fprintf (headerfile, "%s", t->symbol->name);
 395         break;
 396     case TInteger:
 397         if(t->members == NULL) {
 398             fprintf (headerfile, "INTEGER");
 399             if (t->range)
 400                 fprintf (headerfile, " (%d..%d)",
 401                          t->range->min, t->range->max);
 402         } else {
 403             Member *m;
 404             fprintf (headerfile, "INTEGER {\n");
 405             ASN1_TAILQ_FOREACH(m, t->members, members) {
 406                 space (level + 1);
 407                 fprintf(headerfile, "%s(%d)%s\n", m->gen_name, m->val,
 408                         last_member_p(m));
 409             }
 410             space(level);
 411             fprintf (headerfile, "}");
 412         }
 413         break;
 414     case TBoolean:
 415         fprintf (headerfile, "BOOLEAN");
 416         break;
 417     case TOctetString:
 418         fprintf (headerfile, "OCTET STRING");
 419         break;
 420     case TEnumerated :
 421     case TBitString: {
 422         Member *m;
 423
 424         space(level);
 425         if(t->type == TBitString)
 426             fprintf (headerfile, "BIT STRING {\n");
 427         else
 428             fprintf (headerfile, "ENUMERATED {\n");
 429         ASN1_TAILQ_FOREACH(m, t->members, members) {
 430             space(level + 1);
 431             fprintf (headerfile, "%s(%d)%s\n", m->name, m->val,
 432                      last_member_p(m));
 433         }
 434         space(level);
 435         fprintf (headerfile, "}");
 436         break;
 437     }
 438     case TChoice:
 439     case TSet:
 440     case TSequence: {
 441         Member *m;
 442         int max_width = 0;
 443
 444         if(t->type == TChoice)
 445             fprintf(headerfile, "CHOICE {\n");
 446         else if(t->type == TSet)
 447             fprintf(headerfile, "SET {\n");
 448         else
 449             fprintf(headerfile, "SEQUENCE {\n");
 450         ASN1_TAILQ_FOREACH(m, t->members, members) {
 451             if(strlen(m->name) > max_width)
 452                 max_width = strlen(m->name);
 453         }
 454         max_width += 3;
 455         if(max_width < 16) max_width = 16;
 456         ASN1_TAILQ_FOREACH(m, t->members, members) {
 457             int width = max_width;
 458             space(level + 1);
 459             if (m->ellipsis) {
 460                 fprintf (headerfile, "...");
 461             } else {
 462                 width -= fprintf(headerfile, "%s", m->name);
 463                 fprintf(headerfile, "%*s", width, "");
 464                 define_asn1(level + 1, m->type);
 465                 if(m->optional)
 466                     fprintf(headerfile, " OPTIONAL");
 467             }
 468             if(last_member_p(m))
 469                 fprintf (headerfile, ",");
 470             fprintf (headerfile, "\n");
 471         }
 472         space(level);
 473         fprintf (headerfile, "}");
 474         break;
 475     }
 476     case TSequenceOf:
 477         fprintf (headerfile, "SEQUENCE OF ");
 478         define_asn1 (0, t->subtype);
 479         break;
 480     case TSetOf:
 481         fprintf (headerfile, "SET OF ");
 482         define_asn1 (0, t->subtype);
 483         break;
 484     case TGeneralizedTime:
 485         fprintf (headerfile, "GeneralizedTime");
 486         break;
 487     case TGeneralString:
 488         fprintf (headerfile, "GeneralString");
 489         break;
 490     case TTag: {
 491         const char *classnames[] = { "UNIVERSAL ", "APPLICATION ",
 492                                      "" /* CONTEXT */, "PRIVATE " };
 493         if(t->tag.tagclass != ASN1_C_UNIV)
 494             fprintf (headerfile, "[%s%d] ",
 495                      classnames[t->tag.tagclass],
 496                      t->tag.tagvalue);
 497         if(t->tag.tagenv == TE_IMPLICIT)
 498             fprintf (headerfile, "IMPLICIT ");
 499         define_asn1 (level, t->subtype);
 500         break;
 501     }
 502     case TUTCTime:
 503         fprintf (headerfile, "UTCTime");
 504         break;
 505     case TUTF8String:
 506         space(level);
 507         fprintf (headerfile, "UTF8String");
 508         break;
 509     case TPrintableString:
 510         space(level);
 511         fprintf (headerfile, "PrintableString");
 512         break;
 513     case TIA5String:
 514         space(level);
 515         fprintf (headerfile, "IA5String");
 516         break;
 517     case TBMPString:
 518         space(level);
 519         fprintf (headerfile, "BMPString");
 520         break;
 521     case TUniversalString:
 522         space(level);
 523         fprintf (headerfile, "UniversalString");
 524         break;
 525     case TVisibleString:
 526         space(level);
 527         fprintf (headerfile, "VisibleString");
 528         break;
 529     case TOID :
 530         space(level);
 531         fprintf(headerfile, "OBJECT IDENTIFIER");
 532         break;
 533     case TNull:
 534         space(level);
 535         fprintf (headerfile, "NULL");
 536         break;
 537     default:
 538         abort ();
 539     }
 540 }
 541
 542 static void
 543 define_type (int level, const char *name, Type *t, int typedefp, int preservep)
 544 {
 545     switch (t->type) {
 546     case TType:
 547         space(level);
 548         fprintf (headerfile, "%s %s;\n", t->symbol->gen_name, name);
 549         break;
 550     case TInteger:
 551         space(level);
 552         if(t->members) {
 553             Member *m;
 554             fprintf (headerfile, "enum %s {\n", typedefp ? name : "");
 555             ASN1_TAILQ_FOREACH(m, t->members, members) {
 556                 space (level + 1);
 557                 fprintf(headerfile, "%s = %d%s\n", m->gen_name, m->val,
 558                         last_member_p(m));
 559             }
 560             fprintf (headerfile, "} %s;\n", name);
 561         } else if (t->range == NULL) {
 562             fprintf (headerfile, "heim_integer %s;\n", name);
 563         } else if (t->range->min == INT_MIN && t->range->max == INT_MAX) {
 564             fprintf (headerfile, "int %s;\n", name);
 565         } else if (t->range->min == 0 && t->range->max == UINT_MAX) {
 566             fprintf (headerfile, "unsigned int %s;\n", name);
 567         } else if (t->range->min == 0 && t->range->max == INT_MAX) {
 568             fprintf (headerfile, "unsigned int %s;\n", name);
 569         } else
 570             errx(1, "%s: unsupported range %d -> %d",
 571                  name, t->range->min, t->range->max);
 572         break;
 573     case TBoolean:
 574         space(level);
 575         fprintf (headerfile, "int %s;\n", name);
 576         break;
 577     case TOctetString:
 578         space(level);
 579         fprintf (headerfile, "heim_octet_string %s;\n", name);
 580         break;
 581     case TBitString: {
 582         Member *m;
 583         Type i;
 584         struct range range = { 0, INT_MAX };
 585
 586         i.type = TInteger;
 587         i.range = &range;
 588         i.members = NULL;
 589         i.constraint = NULL;
 590
 591         space(level);
 592         if(ASN1_TAILQ_EMPTY(t->members))
 593             fprintf (headerfile, "heim_bit_string %s;\n", name);
 594         else {
 595             fprintf (headerfile, "struct %s {\n", typedefp ? name : "");
 596             ASN1_TAILQ_FOREACH(m, t->members, members) {
 597                 char *n;
 598
 599                 asprintf (&n, "%s:1", m->gen_name);
 600                 if (n == NULL)
 601                     errx(1, "malloc");
 602                 define_type (level + 1, n, &i, FALSE, FALSE);
 603                 free (n);
 604             }
 605             space(level);
 606             fprintf (headerfile, "} %s;\n\n", name);
 607         }
 608         break;
 609     }
 610     case TEnumerated: {
 611         Member *m;
 612
 613         space(level);
 614         fprintf (headerfile, "enum %s {\n", typedefp ? name : "");
 615         ASN1_TAILQ_FOREACH(m, t->members, members) {
 616             space(level + 1);
 617             if (m->ellipsis)
 618                 fprintf (headerfile, "/* ... */\n");
 619             else
 620                 fprintf (headerfile, "%s = %d%s\n", m->gen_name, m->val,
 621                          last_member_p(m));
 622         }
 623         space(level);
 624         fprintf (headerfile, "} %s;\n\n", name);
 625         break;
 626     }
 627     case TSet:
 628     case TSequence: {
 629         Member *m;
 630
 631         space(level);
 632         fprintf (headerfile, "struct %s {\n", typedefp ? name : "");
 633         if (t->type == TSequence && preservep) {
 634             space(level + 1);
 635             fprintf(headerfile, "heim_octet_string _save;\n");
 636         }
 637         ASN1_TAILQ_FOREACH(m, t->members, members) {
 638             if (m->ellipsis) {
 639                 ;
 640             } else if (m->optional) {
 641                 char *n;
 642
 643                 asprintf (&n, "*%s", m->gen_name);
 644                 if (n == NULL)
 645                     errx(1, "malloc");
 646                 define_type (level + 1, n, m->type, FALSE, FALSE);
 647                 free (n);
 648             } else
 649                 define_type (level + 1, m->gen_name, m->type, FALSE, FALSE);
 650         }
 651         space(level);
 652         fprintf (headerfile, "} %s;\n", name);
 653         break;
 654     }
 655     case TSetOf:
 656     case TSequenceOf: {
 657         Type i;
 658         struct range range = { 0, INT_MAX };
 659
 660         i.type = TInteger;
 661         i.range = &range;
 662         i.members = NULL;
 663         i.constraint = NULL;
 664
 665         space(level);
 666         fprintf (headerfile, "struct %s {\n", typedefp ? name : "");
 667         define_type (level + 1, "len", &i, FALSE, FALSE);
 668         define_type (level + 1, "*val", t->subtype, FALSE, FALSE);
 669         space(level);
 670         fprintf (headerfile, "} %s;\n", name);
 671         break;
 672     }
 673     case TGeneralizedTime:
 674         space(level);
 675         fprintf (headerfile, "time_t %s;\n", name);
 676         break;
 677     case TGeneralString:
 678         space(level);
 679         fprintf (headerfile, "heim_general_string %s;\n", name);
 680         break;
 681     case TTag:
 682         define_type (level, name, t->subtype, typedefp, preservep);
 683         break;
 684     case TChoice: {
 685         int first = 1;
 686         Member *m;
 687
 688         space(level);
 689         fprintf (headerfile, "struct %s {\n", typedefp ? name : "");
 690         if (preservep) {
 691             space(level + 1);
 692             fprintf(headerfile, "heim_octet_string _save;\n");
 693         }
 694         space(level + 1);
 695         fprintf (headerfile, "enum {\n");
 696         m = have_ellipsis(t);
 697         if (m) {
 698             space(level + 2);
 699             fprintf (headerfile, "%s = 0,\n", m->label);
 700             first = 0;
 701         }
 702         ASN1_TAILQ_FOREACH(m, t->members, members) {
 703             space(level + 2);
 704             if (m->ellipsis)
 705                 fprintf (headerfile, "/* ... */\n");
 706             else
 707                 fprintf (headerfile, "%s%s%s\n", m->label,
 708                          first ? " = 1" : "",
 709                          last_member_p(m));
 710             first = 0;
 711         }
 712         space(level + 1);
 713         fprintf (headerfile, "} element;\n");
 714         space(level + 1);
 715         fprintf (headerfile, "union {\n");
 716         ASN1_TAILQ_FOREACH(m, t->members, members) {
 717             if (m->ellipsis) {
 718                 space(level + 2);
 719                 fprintf(headerfile, "heim_octet_string asn1_ellipsis;\n");
 720             } else if (m->optional) {
 721                 char *n;
 722
 723                 asprintf (&n, "*%s", m->gen_name);
 724                 if (n == NULL)
 725                     errx(1, "malloc");
 726                 define_type (level + 2, n, m->type, FALSE, FALSE);
 727                 free (n);
 728             } else
 729                 define_type (level + 2, m->gen_name, m->type, FALSE, FALSE);
 730         }
 731         space(level + 1);
 732         fprintf (headerfile, "} u;\n");
 733         space(level);
 734         fprintf (headerfile, "} %s;\n", name);
 735         break;
 736     }
 737     case TUTCTime:
 738         space(level);
 739         fprintf (headerfile, "time_t %s;\n", name);
 740         break;
 741     case TUTF8String:
 742         space(level);
 743         fprintf (headerfile, "heim_utf8_string %s;\n", name);
 744         break;
 745     case TPrintableString:
 746         space(level);
 747         fprintf (headerfile, "heim_printable_string %s;\n", name);
 748         break;
 749     case TIA5String:
 750         space(level);
 751         fprintf (headerfile, "heim_ia5_string %s;\n", name);
 752         break;
 753     case TBMPString:
 754         space(level);
 755         fprintf (headerfile, "heim_bmp_string %s;\n", name);
 756         break;
 757     case TUniversalString:
 758         space(level);
 759         fprintf (headerfile, "heim_universal_string %s;\n", name);
 760         break;
 761     case TVisibleString:
 762         space(level);
 763         fprintf (headerfile, "heim_visible_string %s;\n", name);
 764         break;
 765     case TOID :
 766         space(level);
 767         fprintf (headerfile, "heim_oid %s;\n", name);
 768         break;
 769     case TNull:
 770         space(level);
 771         fprintf (headerfile, "int %s;\n", name);
 772         break;
 773     default:
 774         abort ();
 775     }
 776 }
 777
 778 static void
 779 generate_type_header (const Symbol *s)
 780 {
 781     int preservep = preserve_type(s->name) ? TRUE : FALSE;
 782
 783     fprintf (headerfile, "/*\n");
 784     fprintf (headerfile, "%s ::= ", s->name);
 785     define_asn1 (0, s->type);
 786     fprintf (headerfile, "\n*/\n\n");
 787
 788     fprintf (headerfile, "typedef ");
 789     define_type (0, s->gen_name, s->type, TRUE, preservep);
 790
 791     fprintf (headerfile, "\n");
 792 }
 793
 794
 795 void
 796 generate_type (const Symbol *s)
 797 {
 798     if (!one_code_file)
 799         generate_header_of_codefile(s->gen_name);
 800
 801     generate_type_header (s);
 802     generate_type_encode (s);
 803     generate_type_decode (s);
 804     generate_type_free (s);
 805     generate_type_length (s);
 806     generate_type_copy (s);
 807     generate_type_seq (s);
 808     generate_glue (s->type, s->gen_name);
 809     fprintf(headerfile, "\n\n");
 810
 811     if (!one_code_file) {
 812         fprintf(codefile, "\n\n");
 813         close_codefile();
 814         }
 815 }