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