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