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
38RCSID("$Id$");
39
40FILE *privheaderfile, *headerfile, *codefile, *logfile, *templatefile;
41
42#define STEM "asn1"
43
44static const char *orig_filename;
45static char *privheader, *header, *template;
46static const char *headerbase = STEM;
47
48/*
49 * list of all IMPORTs
50 */
51
52struct import {
53    const char *module;
54    struct import *next;
55};
56
57static struct import *imports = NULL;
58
59void
60add_import (const char *module)
61{
62    struct import *tmp = emalloc (sizeof(*tmp));
63
64    tmp->module = module;
65    tmp->next   = imports;
66    imports     = tmp;
67
68    fprintf (headerfile, "#include <%s_asn1.h>\n", module);
69}
70
71/*
72 * List of all exported symbols
73 */
74
75struct sexport {
76    const char *name;
77    int defined;
78    struct sexport *next;
79};
80
81static struct sexport *exports = NULL;
82
83void
84add_export (const char *name)
85{
86    struct sexport *tmp = emalloc (sizeof(*tmp));
87
88    tmp->name   = name;
89    tmp->next   = exports;
90    exports     = tmp;
91}
92
93int
94is_export(const char *name)
95{
96    struct sexport *tmp;
97
98    if (exports == NULL) /* no export list, all exported */
99	return 1;
100
101    for (tmp = exports; tmp != NULL; tmp = tmp->next) {
102	if (strcmp(tmp->name, name) == 0) {
103	    tmp->defined = 1;
104	    return 1;
105	}
106    }
107    return 0;
108}
109
110const char *
111get_filename (void)
112{
113    return orig_filename;
114}
115
116void
117init_generate (const char *filename, const char *base)
118{
119    char *fn = NULL;
120
121    orig_filename = filename;
122    if (base != NULL) {
123	headerbase = strdup(base);
124	if (headerbase == NULL)
125	    errx(1, "strdup");
126    }
127
128    /* public header file */
129    if (asprintf(&header, "%s.h", headerbase) < 0 || header == NULL)
130	errx(1, "malloc");
131    if (asprintf(&fn, "%s.hx", headerbase) < 0 || fn == NULL)
132	errx(1, "malloc");
133    headerfile = fopen (fn, "w");
134    if (headerfile == NULL)
135	err (1, "open %s", fn);
136    free(fn);
137    fn = NULL;
138
139    /* private header file */
140    if (asprintf(&privheader, "%s-priv.h", headerbase) < 0 || privheader == NULL)
141	errx(1, "malloc");
142    if (asprintf(&fn, "%s-priv.hx", headerbase) < 0 || fn == NULL)
143	errx(1, "malloc");
144    privheaderfile = fopen (fn, "w");
145    if (privheaderfile == NULL)
146	err (1, "open %s", fn);
147    free(fn);
148    fn = NULL;
149
150    /* template file */
151    if (asprintf(&template, "%s-template.c", headerbase) < 0 || template == NULL)
152	errx(1, "malloc");
153    fprintf (headerfile,
154	     "/* Generated from %s */\n"
155	     "/* Do not edit */\n\n",
156	     filename);
157    fprintf (headerfile,
158	     "#ifndef __%s_h__\n"
159	     "#define __%s_h__\n\n", headerbase, headerbase);
160    fprintf (headerfile,
161	     "#include <stddef.h>\n"
162	     "#include <time.h>\n\n");
163    fprintf (headerfile,
164	     "#ifndef __asn1_common_definitions__\n"
165	     "#define __asn1_common_definitions__\n\n");
166    fprintf (headerfile,
167	     "typedef struct heim_integer {\n"
168	     "  size_t length;\n"
169	     "  void *data;\n"
170	     "  int negative;\n"
171	     "} heim_integer;\n\n");
172    fprintf (headerfile,
173	     "typedef struct heim_octet_string {\n"
174	     "  size_t length;\n"
175	     "  void *data;\n"
176	     "} heim_octet_string;\n\n");
177    fprintf (headerfile,
178	     "typedef char *heim_general_string;\n\n"
179	     );
180    fprintf (headerfile,
181	     "typedef char *heim_utf8_string;\n\n"
182	     );
183    fprintf (headerfile,
184	     "typedef struct heim_octet_string heim_printable_string;\n\n"
185	     );
186    fprintf (headerfile,
187	     "typedef struct heim_octet_string heim_ia5_string;\n\n"
188	     );
189    fprintf (headerfile,
190	     "typedef struct heim_bmp_string {\n"
191	     "  size_t length;\n"
192	     "  uint16_t *data;\n"
193	     "} heim_bmp_string;\n\n");
194    fprintf (headerfile,
195	     "typedef struct heim_universal_string {\n"
196	     "  size_t length;\n"
197	     "  uint32_t *data;\n"
198	     "} heim_universal_string;\n\n");
199    fprintf (headerfile,
200	     "typedef char *heim_visible_string;\n\n"
201	     );
202    fprintf (headerfile,
203	     "typedef struct heim_oid {\n"
204	     "  size_t length;\n"
205	     "  unsigned *components;\n"
206	     "} heim_oid;\n\n");
207    fprintf (headerfile,
208	     "typedef struct heim_bit_string {\n"
209	     "  size_t length;\n"
210	     "  void *data;\n"
211	     "} heim_bit_string;\n\n");
212    fprintf (headerfile,
213	     "typedef struct heim_octet_string heim_any;\n"
214	     "typedef struct heim_octet_string heim_any_set;\n\n");
215    fputs("#define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R)                  \\\n"
216	  "  do {                                                         \\\n"
217	  "    (BL) = length_##T((S));                                    \\\n"
218	  "    (B) = malloc((BL));                                        \\\n"
219	  "    if((B) == NULL) {                                          \\\n"
220	  "      (R) = ENOMEM;                                            \\\n"
221	  "    } else {                                                   \\\n"
222	  "      (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \\\n"
223	  "                       (S), (L));                              \\\n"
224	  "      if((R) != 0) {                                           \\\n"
225	  "        free((B));                                             \\\n"
226	  "        (B) = NULL;                                            \\\n"
227	  "      }                                                        \\\n"
228	  "    }                                                          \\\n"
229	  "  } while (0)\n\n",
230	  headerfile);
231    fputs("#ifdef _WIN32\n"
232	  "#ifndef ASN1_LIB\n"
233	  "#define ASN1EXP  __declspec(dllimport)\n"
234	  "#else\n"
235	  "#define ASN1EXP\n"
236	  "#endif\n"
237	  "#define ASN1CALL __stdcall\n"
238	  "#else\n"
239	  "#define ASN1EXP\n"
240	  "#define ASN1CALL\n"
241	  "#endif\n",
242	  headerfile);
243    fprintf (headerfile, "struct units;\n\n");
244    fprintf (headerfile, "#endif\n\n");
245    if (asprintf(&fn, "%s_files", base) < 0 || fn == NULL)
246	errx(1, "malloc");
247    logfile = fopen(fn, "w");
248    if (logfile == NULL)
249	err (1, "open %s", fn);
250
251    /* if one code file, write into the one codefile */
252    if (one_code_file)
253	return;
254
255    templatefile = fopen (template, "w");
256    if (templatefile == NULL)
257	err (1, "open %s", template);
258
259    fprintf (templatefile,
260	     "/* Generated from %s */\n"
261	     "/* Do not edit */\n\n"
262	     "#include <stdio.h>\n"
263	     "#include <stdlib.h>\n"
264	     "#include <time.h>\n"
265	     "#include <string.h>\n"
266	     "#include <errno.h>\n"
267	     "#include <limits.h>\n"
268	     "#include <krb5-types.h>\n",
269	     filename);
270
271    fprintf (templatefile,
272	     "#include <%s>\n"
273	     "#include <%s>\n"
274	     "#include <der.h>\n"
275	     "#include <der-private.h>\n"
276	     "#include <asn1-template.h>\n",
277	     header, privheader);
278
279
280}
281
282void
283close_generate (void)
284{
285    fprintf (headerfile, "#endif /* __%s_h__ */\n", headerbase);
286
287    if (headerfile)
288        fclose (headerfile);
289    if (privheaderfile)
290        fclose (privheaderfile);
291    if (templatefile)
292        fclose (templatefile);
293    if (logfile)
294        fprintf (logfile, "\n");
295        fclose (logfile);
296}
297
298void
299gen_assign_defval(const char *var, struct value *val)
300{
301    switch(val->type) {
302    case stringvalue:
303	fprintf(codefile, "if((%s = strdup(\"%s\")) == NULL)\nreturn ENOMEM;\n", var, val->u.stringvalue);
304	break;
305    case integervalue:
306	fprintf(codefile, "%s = %" PRId64 ";\n", var, val->u.integervalue);
307	break;
308    case booleanvalue:
309	if(val->u.booleanvalue)
310	    fprintf(codefile, "%s = TRUE;\n", var);
311	else
312	    fprintf(codefile, "%s = FALSE;\n", var);
313	break;
314    default:
315	abort();
316    }
317}
318
319void
320gen_compare_defval(const char *var, struct value *val)
321{
322    switch(val->type) {
323    case stringvalue:
324	fprintf(codefile, "if(strcmp(%s, \"%s\") != 0)\n", var, val->u.stringvalue);
325	break;
326    case integervalue:
327	fprintf(codefile, "if(%s != %" PRId64 ")\n", var, val->u.integervalue);
328	break;
329    case booleanvalue:
330	if(val->u.booleanvalue)
331	    fprintf(codefile, "if(!%s)\n", var);
332	else
333	    fprintf(codefile, "if(%s)\n", var);
334	break;
335    default:
336	abort();
337    }
338}
339
340void
341generate_header_of_codefile(const char *name)
342{
343    char *filename = NULL;
344
345    if (codefile != NULL)
346	abort();
347
348    if (asprintf (&filename, "%s_%s.x", STEM, name) < 0 || filename == NULL)
349	errx(1, "malloc");
350    codefile = fopen (filename, "w");
351    if (codefile == NULL)
352	err (1, "fopen %s", filename);
353    fprintf(logfile, "%s ", filename);
354    free(filename);
355    filename = NULL;
356    fprintf (codefile,
357	     "/* Generated from %s */\n"
358	     "/* Do not edit */\n\n"
359	     "#define  ASN1_LIB\n\n"
360	     "#include <stdio.h>\n"
361	     "#include <stdlib.h>\n"
362	     "#include <time.h>\n"
363	     "#include <string.h>\n"
364	     "#include <errno.h>\n"
365	     "#include <limits.h>\n"
366	     "#include <krb5-types.h>\n",
367	     orig_filename);
368
369    fprintf (codefile,
370	     "#include <%s>\n"
371	     "#include <%s>\n",
372	     header, privheader);
373    fprintf (codefile,
374	     "#include <asn1_err.h>\n"
375	     "#include <der.h>\n"
376	     "#include <der-private.h>\n"
377	     "#include <asn1-template.h>\n"
378	     "#include <parse_units.h>\n\n");
379
380}
381
382void
383close_codefile(void)
384{
385    if (codefile == NULL)
386	abort();
387
388    fclose(codefile);
389    codefile = NULL;
390}
391
392
393void
394generate_constant (const Symbol *s)
395{
396    switch(s->value->type) {
397    case booleanvalue:
398	break;
399    case integervalue:
400	fprintf (headerfile, "enum { %s = %" PRId64 " };\n\n",
401		 s->gen_name, s->value->u.integervalue);
402	break;
403    case nullvalue:
404	break;
405    case stringvalue:
406	break;
407    case objectidentifiervalue: {
408	struct objid *o, **list;
409	unsigned int i, len;
410	char *gen_upper;
411
412	if (!one_code_file)
413	    generate_header_of_codefile(s->gen_name);
414
415	len = 0;
416	for (o = s->value->u.objectidentifiervalue; o != NULL; o = o->next)
417	    len++;
418	if (len == 0) {
419	    printf("s->gen_name: %s",s->gen_name);
420	    fflush(stdout);
421	    break;
422	}
423	list = emalloc(sizeof(*list) * len);
424
425	i = 0;
426	for (o = s->value->u.objectidentifiervalue; o != NULL; o = o->next)
427	    list[i++] = o;
428
429	fprintf (headerfile, "/* OBJECT IDENTIFIER %s ::= { ", s->name);
430	for (i = len ; i > 0; i--) {
431	    o = list[i - 1];
432	    fprintf(headerfile, "%s(%d) ",
433		    o->label ? o->label : "label-less", o->value);
434	}
435
436	fprintf (codefile, "static unsigned oid_%s_variable_num[%d] =  {",
437		 s->gen_name, len);
438	for (i = len ; i > 0; i--) {
439	    fprintf(codefile, "%d%s ", list[i - 1]->value, i > 1 ? "," : "");
440	}
441	fprintf(codefile, "};\n");
442
443	fprintf (codefile, "const heim_oid asn1_oid_%s = "
444		 "{ %d, oid_%s_variable_num };\n\n",
445		 s->gen_name, len, s->gen_name);
446
447	free(list);
448
449	/* header file */
450
451	gen_upper = strdup(s->gen_name);
452	len = strlen(gen_upper);
453	for (i = 0; i < len; i++)
454	    gen_upper[i] = toupper((int)s->gen_name[i]);
455
456	fprintf (headerfile, "} */\n");
457	fprintf (headerfile,
458		 "extern ASN1EXP const heim_oid asn1_oid_%s;\n"
459		 "#define ASN1_OID_%s (&asn1_oid_%s)\n\n",
460		 s->gen_name,
461		 gen_upper,
462		 s->gen_name);
463
464	free(gen_upper);
465
466	if (!one_code_file)
467	    close_codefile();
468
469	break;
470    }
471    default:
472	abort();
473    }
474}
475
476int
477is_primitive_type(int type)
478{
479    switch(type) {
480    case TInteger:
481    case TBoolean:
482    case TOctetString:
483    case TBitString:
484    case TEnumerated:
485    case TGeneralizedTime:
486    case TGeneralString:
487    case TTeletexString:
488    case TOID:
489    case TUTCTime:
490    case TUTF8String:
491    case TPrintableString:
492    case TIA5String:
493    case TBMPString:
494    case TUniversalString:
495    case TVisibleString:
496    case TNull:
497	return 1;
498    default:
499	return 0;
500    }
501}
502
503static void
504space(int level)
505{
506    while(level-- > 0)
507	fprintf(headerfile, "  ");
508}
509
510static const char *
511last_member_p(struct member *m)
512{
513    struct member *n = ASN1_TAILQ_NEXT(m, members);
514    if (n == NULL)
515	return "";
516    if (n->ellipsis && ASN1_TAILQ_NEXT(n, members) == NULL)
517	return "";
518    return ",";
519}
520
521static struct member *
522have_ellipsis(Type *t)
523{
524    struct member *m;
525    ASN1_TAILQ_FOREACH(m, t->members, members) {
526	if (m->ellipsis)
527	    return m;
528    }
529    return NULL;
530}
531
532static void
533define_asn1 (int level, Type *t)
534{
535    switch (t->type) {
536    case TType:
537	fprintf (headerfile, "%s", t->symbol->name);
538	break;
539    case TInteger:
540	if(t->members == NULL) {
541            fprintf (headerfile, "INTEGER");
542	    if (t->range)
543		fprintf (headerfile, " (%" PRId64 "..%" PRId64 ")",
544			 t->range->min, t->range->max);
545        } else {
546	    Member *m;
547            fprintf (headerfile, "INTEGER {\n");
548	    ASN1_TAILQ_FOREACH(m, t->members, members) {
549                space (level + 1);
550		fprintf(headerfile, "%s(%d)%s\n", m->gen_name, m->val,
551			last_member_p(m));
552            }
553	    space(level);
554            fprintf (headerfile, "}");
555        }
556	break;
557    case TBoolean:
558	fprintf (headerfile, "BOOLEAN");
559	break;
560    case TOctetString:
561	fprintf (headerfile, "OCTET STRING");
562	break;
563    case TEnumerated :
564    case TBitString: {
565	Member *m;
566
567	space(level);
568	if(t->type == TBitString)
569	    fprintf (headerfile, "BIT STRING {\n");
570	else
571	    fprintf (headerfile, "ENUMERATED {\n");
572	ASN1_TAILQ_FOREACH(m, t->members, members) {
573	    space(level + 1);
574	    fprintf (headerfile, "%s(%d)%s\n", m->name, m->val,
575		     last_member_p(m));
576	}
577	space(level);
578	fprintf (headerfile, "}");
579	break;
580    }
581    case TChoice:
582    case TSet:
583    case TSequence: {
584	Member *m;
585	int max_width = 0;
586
587	if(t->type == TChoice)
588	    fprintf(headerfile, "CHOICE {\n");
589	else if(t->type == TSet)
590	    fprintf(headerfile, "SET {\n");
591	else
592	    fprintf(headerfile, "SEQUENCE {\n");
593	ASN1_TAILQ_FOREACH(m, t->members, members) {
594	    if(strlen(m->name) > max_width)
595		max_width = strlen(m->name);
596	}
597	max_width += 3;
598	if(max_width < 16) max_width = 16;
599	ASN1_TAILQ_FOREACH(m, t->members, members) {
600	    int width = max_width;
601	    space(level + 1);
602	    if (m->ellipsis) {
603		fprintf (headerfile, "...");
604	    } else {
605		width -= fprintf(headerfile, "%s", m->name);
606		fprintf(headerfile, "%*s", width, "");
607		define_asn1(level + 1, m->type);
608		if(m->optional)
609		    fprintf(headerfile, " OPTIONAL");
610	    }
611	    if(last_member_p(m))
612		fprintf (headerfile, ",");
613	    fprintf (headerfile, "\n");
614	}
615	space(level);
616	fprintf (headerfile, "}");
617	break;
618    }
619    case TSequenceOf:
620	fprintf (headerfile, "SEQUENCE OF ");
621	define_asn1 (0, t->subtype);
622	break;
623    case TSetOf:
624	fprintf (headerfile, "SET OF ");
625	define_asn1 (0, t->subtype);
626	break;
627    case TGeneralizedTime:
628	fprintf (headerfile, "GeneralizedTime");
629	break;
630    case TGeneralString:
631	fprintf (headerfile, "GeneralString");
632	break;
633    case TTeletexString:
634	fprintf (headerfile, "TeletexString");
635	break;
636    case TTag: {
637	const char *classnames[] = { "UNIVERSAL ", "APPLICATION ",
638				     "" /* CONTEXT */, "PRIVATE " };
639	if(t->tag.tagclass != ASN1_C_UNIV)
640	    fprintf (headerfile, "[%s%d] ",
641		     classnames[t->tag.tagclass],
642		     t->tag.tagvalue);
643	if(t->tag.tagenv == TE_IMPLICIT)
644	    fprintf (headerfile, "IMPLICIT ");
645	define_asn1 (level, t->subtype);
646	break;
647    }
648    case TUTCTime:
649	fprintf (headerfile, "UTCTime");
650	break;
651    case TUTF8String:
652	space(level);
653	fprintf (headerfile, "UTF8String");
654	break;
655    case TPrintableString:
656	space(level);
657	fprintf (headerfile, "PrintableString");
658	break;
659    case TIA5String:
660	space(level);
661	fprintf (headerfile, "IA5String");
662	break;
663    case TBMPString:
664	space(level);
665	fprintf (headerfile, "BMPString");
666	break;
667    case TUniversalString:
668	space(level);
669	fprintf (headerfile, "UniversalString");
670	break;
671    case TVisibleString:
672	space(level);
673	fprintf (headerfile, "VisibleString");
674	break;
675    case TOID :
676	space(level);
677	fprintf(headerfile, "OBJECT IDENTIFIER");
678	break;
679    case TNull:
680	space(level);
681	fprintf (headerfile, "NULL");
682	break;
683    default:
684	abort ();
685    }
686}
687
688static void
689getnewbasename(char **newbasename, int typedefp, const char *basename, const char *name)
690{
691    if (typedefp)
692	*newbasename = strdup(name);
693    else {
694	if (name[0] == '*')
695	    name++;
696	if (asprintf(newbasename, "%s_%s", basename, name) < 0)
697	    errx(1, "malloc");
698    }
699    if (*newbasename == NULL)
700	err(1, "malloc");
701}
702
703static void
704define_type (int level, const char *name, const char *basename, Type *t, int typedefp, int preservep)
705{
706    char *newbasename = NULL;
707
708    switch (t->type) {
709    case TType:
710	space(level);
711	fprintf (headerfile, "%s %s;\n", t->symbol->gen_name, name);
712	break;
713    case TInteger:
714	space(level);
715	if(t->members) {
716            Member *m;
717            fprintf (headerfile, "enum %s {\n", typedefp ? name : "");
718	    ASN1_TAILQ_FOREACH(m, t->members, members) {
719                space (level + 1);
720                fprintf(headerfile, "%s = %d%s\n", m->gen_name, m->val,
721                        last_member_p(m));
722            }
723            fprintf (headerfile, "} %s;\n", name);
724	} else if (t->range == NULL) {
725	    fprintf (headerfile, "heim_integer %s;\n", name);
726	} else if (t->range->min < INT_MIN && t->range->max <= INT64_MAX) {
727	    fprintf (headerfile, "int64_t %s;\n", name);
728	} else if (t->range->min >= 0 && t->range->max > UINT_MAX) {
729	    fprintf (headerfile, "uint64_t %s;\n", name);
730	} else if (t->range->min >= 0 && t->range->max <= UINT_MAX) {
731	    fprintf (headerfile, "unsigned int %s;\n", name);
732	} else if (t->range->min >= INT_MIN && t->range->max <= INT_MAX) {
733	    fprintf (headerfile, "int %s;\n", name);
734	} else
735	    errx(1, "%s: unsupported range %" PRId64 " -> %" PRId64 "",
736		 name, t->range->min, t->range->max);
737	break;
738    case TBoolean:
739	space(level);
740	fprintf (headerfile, "int %s;\n", name);
741	break;
742    case TOctetString:
743	space(level);
744	fprintf (headerfile, "heim_octet_string %s;\n", name);
745	break;
746    case TBitString: {
747	Member *m;
748	Type i;
749	struct range range = { 0, INT_MAX };
750
751	i.type = TInteger;
752	i.range = &range;
753	i.members = NULL;
754	i.constraint = NULL;
755
756	space(level);
757	if(ASN1_TAILQ_EMPTY(t->members))
758	    fprintf (headerfile, "heim_bit_string %s;\n", name);
759	else {
760	    int pos = 0;
761	    getnewbasename(&newbasename, typedefp, basename, name);
762
763	    fprintf (headerfile, "struct %s {\n", newbasename);
764	    ASN1_TAILQ_FOREACH(m, t->members, members) {
765		char *n = NULL;
766
767		/* pad unused */
768		while (pos < m->val) {
769		    if (asprintf (&n, "_unused%d:1", pos) < 0 || n == NULL)
770			errx(1, "malloc");
771		    define_type (level + 1, n, newbasename, &i, FALSE, FALSE);
772		    free(n);
773		    pos++;
774		}
775
776		n = NULL;
777		if (asprintf (&n, "%s:1", m->gen_name) < 0 || n == NULL)
778		    errx(1, "malloc");
779		define_type (level + 1, n, newbasename, &i, FALSE, FALSE);
780		free (n);
781		n = NULL;
782		pos++;
783	    }
784	    /* pad to 32 elements */
785	    while (pos < 32) {
786		char *n = NULL;
787		if (asprintf (&n, "_unused%d:1", pos) < 0 || n == NULL)
788		    errx(1, "malloc");
789		define_type (level + 1, n, newbasename, &i, FALSE, FALSE);
790		free(n);
791		pos++;
792	    }
793
794	    space(level);
795	    fprintf (headerfile, "} %s;\n\n", name);
796	}
797	break;
798    }
799    case TEnumerated: {
800	Member *m;
801
802	space(level);
803	fprintf (headerfile, "enum %s {\n", typedefp ? name : "");
804	ASN1_TAILQ_FOREACH(m, t->members, members) {
805	    space(level + 1);
806	    if (m->ellipsis)
807		fprintf (headerfile, "/* ... */\n");
808	    else
809		fprintf (headerfile, "%s = %d%s\n", m->gen_name, m->val,
810			 last_member_p(m));
811	}
812	space(level);
813	fprintf (headerfile, "} %s;\n\n", name);
814	break;
815    }
816    case TSet:
817    case TSequence: {
818	Member *m;
819
820	getnewbasename(&newbasename, typedefp, basename, name);
821
822	space(level);
823	fprintf (headerfile, "struct %s {\n", newbasename);
824	if (t->type == TSequence && preservep) {
825	    space(level + 1);
826	    fprintf(headerfile, "heim_octet_string _save;\n");
827	}
828	ASN1_TAILQ_FOREACH(m, t->members, members) {
829	    if (m->ellipsis) {
830		;
831	    } else if (m->optional) {
832		char *n = NULL;
833
834		if (asprintf (&n, "*%s", m->gen_name) < 0 || n == NULL)
835		    errx(1, "malloc");
836		define_type (level + 1, n, newbasename, m->type, FALSE, FALSE);
837		free (n);
838	    } else
839		define_type (level + 1, m->gen_name, newbasename, m->type, FALSE, FALSE);
840	}
841	space(level);
842	fprintf (headerfile, "} %s;\n", name);
843	break;
844    }
845    case TSetOf:
846    case TSequenceOf: {
847	Type i;
848	struct range range = { 0, INT_MAX };
849
850	getnewbasename(&newbasename, typedefp, basename, name);
851
852	i.type = TInteger;
853	i.range = &range;
854	i.members = NULL;
855	i.constraint = NULL;
856
857	space(level);
858	fprintf (headerfile, "struct %s {\n", newbasename);
859	define_type (level + 1, "len", newbasename, &i, FALSE, FALSE);
860	define_type (level + 1, "*val", newbasename, t->subtype, FALSE, FALSE);
861	space(level);
862	fprintf (headerfile, "} %s;\n", name);
863	break;
864    }
865    case TGeneralizedTime:
866	space(level);
867	fprintf (headerfile, "time_t %s;\n", name);
868	break;
869    case TGeneralString:
870	space(level);
871	fprintf (headerfile, "heim_general_string %s;\n", name);
872	break;
873    case TTeletexString:
874	space(level);
875	fprintf (headerfile, "heim_general_string %s;\n", name);
876	break;
877    case TTag:
878	define_type (level, name, basename, t->subtype, typedefp, preservep);
879	break;
880    case TChoice: {
881	int first = 1;
882	Member *m;
883
884	getnewbasename(&newbasename, typedefp, basename, name);
885
886	space(level);
887	fprintf (headerfile, "struct %s {\n", newbasename);
888	if (preservep) {
889	    space(level + 1);
890	    fprintf(headerfile, "heim_octet_string _save;\n");
891	}
892	space(level + 1);
893	fprintf (headerfile, "enum {\n");
894	m = have_ellipsis(t);
895	if (m) {
896	    space(level + 2);
897	    fprintf (headerfile, "%s = 0,\n", m->label);
898	    first = 0;
899	}
900	ASN1_TAILQ_FOREACH(m, t->members, members) {
901	    space(level + 2);
902	    if (m->ellipsis)
903		fprintf (headerfile, "/* ... */\n");
904	    else
905		fprintf (headerfile, "%s%s%s\n", m->label,
906			 first ? " = 1" : "",
907			 last_member_p(m));
908	    first = 0;
909	}
910	space(level + 1);
911	fprintf (headerfile, "} element;\n");
912	space(level + 1);
913	fprintf (headerfile, "union {\n");
914	ASN1_TAILQ_FOREACH(m, t->members, members) {
915	    if (m->ellipsis) {
916		space(level + 2);
917		fprintf(headerfile, "heim_octet_string asn1_ellipsis;\n");
918	    } else if (m->optional) {
919		char *n = NULL;
920
921		if (asprintf (&n, "*%s", m->gen_name) < 0 || n == NULL)
922		    errx(1, "malloc");
923		define_type (level + 2, n, newbasename, m->type, FALSE, FALSE);
924		free (n);
925	    } else
926		define_type (level + 2, m->gen_name, newbasename, m->type, FALSE, FALSE);
927	}
928	space(level + 1);
929	fprintf (headerfile, "} u;\n");
930	space(level);
931	fprintf (headerfile, "} %s;\n", name);
932	break;
933    }
934    case TUTCTime:
935	space(level);
936	fprintf (headerfile, "time_t %s;\n", name);
937	break;
938    case TUTF8String:
939	space(level);
940	fprintf (headerfile, "heim_utf8_string %s;\n", name);
941	break;
942    case TPrintableString:
943	space(level);
944	fprintf (headerfile, "heim_printable_string %s;\n", name);
945	break;
946    case TIA5String:
947	space(level);
948	fprintf (headerfile, "heim_ia5_string %s;\n", name);
949	break;
950    case TBMPString:
951	space(level);
952	fprintf (headerfile, "heim_bmp_string %s;\n", name);
953	break;
954    case TUniversalString:
955	space(level);
956	fprintf (headerfile, "heim_universal_string %s;\n", name);
957	break;
958    case TVisibleString:
959	space(level);
960	fprintf (headerfile, "heim_visible_string %s;\n", name);
961	break;
962    case TOID :
963	space(level);
964	fprintf (headerfile, "heim_oid %s;\n", name);
965	break;
966    case TNull:
967	space(level);
968	fprintf (headerfile, "int %s;\n", name);
969	break;
970    default:
971	abort ();
972    }
973    if (newbasename)
974	free(newbasename);
975}
976
977static void
978generate_type_header (const Symbol *s)
979{
980    int preservep = preserve_type(s->name) ? TRUE : FALSE;
981
982    fprintf (headerfile, "/*\n");
983    fprintf (headerfile, "%s ::= ", s->name);
984    define_asn1 (0, s->type);
985    fprintf (headerfile, "\n*/\n\n");
986
987    fprintf (headerfile, "typedef ");
988    define_type (0, s->gen_name, s->gen_name, s->type, TRUE, preservep);
989
990    fprintf (headerfile, "\n");
991}
992
993void
994generate_type (const Symbol *s)
995{
996    FILE *h;
997    const char * exp;
998
999    if (!one_code_file)
1000	generate_header_of_codefile(s->gen_name);
1001
1002    generate_type_header (s);
1003
1004    if (template_flag)
1005	generate_template(s);
1006
1007    if (template_flag == 0 || is_template_compat(s) == 0) {
1008	generate_type_encode (s);
1009	generate_type_decode (s);
1010	generate_type_free (s);
1011	generate_type_length (s);
1012	generate_type_copy (s);
1013    }
1014    generate_type_seq (s);
1015    generate_glue (s->type, s->gen_name);
1016
1017    /* generate prototypes */
1018
1019    if (is_export(s->name)) {
1020	h = headerfile;
1021	exp = "ASN1EXP ";
1022    } else {
1023	h = privheaderfile;
1024	exp = "";
1025    }
1026
1027    fprintf (h,
1028	     "%sint    ASN1CALL "
1029	     "decode_%s(const unsigned char *, size_t, %s *, size_t *);\n",
1030	     exp,
1031	     s->gen_name, s->gen_name);
1032    fprintf (h,
1033	     "%sint    ASN1CALL "
1034	     "encode_%s(unsigned char *, size_t, const %s *, size_t *);\n",
1035	     exp,
1036	     s->gen_name, s->gen_name);
1037    fprintf (h,
1038	     "%ssize_t ASN1CALL length_%s(const %s *);\n",
1039	     exp,
1040	     s->gen_name, s->gen_name);
1041    fprintf (h,
1042	     "%sint    ASN1CALL copy_%s  (const %s *, %s *);\n",
1043	     exp,
1044	     s->gen_name, s->gen_name, s->gen_name);
1045    fprintf (h,
1046	     "%svoid   ASN1CALL free_%s  (%s *);\n",
1047	     exp,
1048	     s->gen_name, s->gen_name);
1049
1050    fprintf(h, "\n\n");
1051
1052    if (!one_code_file) {
1053	fprintf(codefile, "\n\n");
1054	close_codefile();
1055	}
1056}
1057