Deleted Added
sdiff udiff text old ( 102644 ) new ( 103423 )
full compact
gen.c (102644) gen.c (103423)
1/*
2 * Copyright (c) 1997 - 2002 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
1/*
2 * Copyright (c) 1997 - 2002 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
36RCSID("$Id: gen.c,v 1.48 2002/08/26 13:27:20 assar Exp $");
36RCSID("$Id: gen.c,v 1.49 2002/09/04 15:06:18 joda Exp $");
37
38FILE *headerfile, *codefile, *logfile;
39
40#define STEM "asn1"
41
42static const char *orig_filename;
43static char header[1024];
44static char headerbase[1024] = STEM;
45
46/*
47 * list of all IMPORTs
48 */
49
50struct import {
51 const char *module;
52 struct import *next;
53};
54
55static struct import *imports = NULL;
56
57void
58add_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
67const char *
68filename (void)
69{
70 return orig_filename;
71}
72
73void
74init_generate (const char *filename, const char *base)
75{
76 orig_filename = filename;
77 if(base)
78 strcpy(headerbase, base);
79 sprintf(header, "%s.h", headerbase);
80 headerfile = fopen (header, "w");
81 if (headerfile == NULL)
82 err (1, "open %s", header);
83 fprintf (headerfile,
84 "/* Generated from %s */\n"
85 "/* Do not edit */\n\n",
86 filename);
87 fprintf (headerfile,
88 "#ifndef __%s_h__\n"
89 "#define __%s_h__\n\n", headerbase, headerbase);
90 fprintf (headerfile,
91 "#include <stddef.h>\n"
92 "#include <time.h>\n\n");
93#ifndef HAVE_TIMEGM
94 fprintf (headerfile, "time_t timegm (struct tm*);\n\n");
95#endif
96 fprintf (headerfile,
97 "#ifndef __asn1_common_definitions__\n"
98 "#define __asn1_common_definitions__\n\n");
99 fprintf (headerfile,
100 "typedef struct octet_string {\n"
101 " size_t length;\n"
102 " void *data;\n"
103 "} octet_string;\n\n");
104 fprintf (headerfile,
37
38FILE *headerfile, *codefile, *logfile;
39
40#define STEM "asn1"
41
42static const char *orig_filename;
43static char header[1024];
44static char headerbase[1024] = STEM;
45
46/*
47 * list of all IMPORTs
48 */
49
50struct import {
51 const char *module;
52 struct import *next;
53};
54
55static struct import *imports = NULL;
56
57void
58add_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
67const char *
68filename (void)
69{
70 return orig_filename;
71}
72
73void
74init_generate (const char *filename, const char *base)
75{
76 orig_filename = filename;
77 if(base)
78 strcpy(headerbase, base);
79 sprintf(header, "%s.h", headerbase);
80 headerfile = fopen (header, "w");
81 if (headerfile == NULL)
82 err (1, "open %s", header);
83 fprintf (headerfile,
84 "/* Generated from %s */\n"
85 "/* Do not edit */\n\n",
86 filename);
87 fprintf (headerfile,
88 "#ifndef __%s_h__\n"
89 "#define __%s_h__\n\n", headerbase, headerbase);
90 fprintf (headerfile,
91 "#include <stddef.h>\n"
92 "#include <time.h>\n\n");
93#ifndef HAVE_TIMEGM
94 fprintf (headerfile, "time_t timegm (struct tm*);\n\n");
95#endif
96 fprintf (headerfile,
97 "#ifndef __asn1_common_definitions__\n"
98 "#define __asn1_common_definitions__\n\n");
99 fprintf (headerfile,
100 "typedef struct octet_string {\n"
101 " size_t length;\n"
102 " void *data;\n"
103 "} octet_string;\n\n");
104 fprintf (headerfile,
105#if 0
106 "typedef struct general_string {\n"
107 " size_t length;\n"
108 " char *data;\n"
109 "} general_string;\n\n"
110#else
111 "typedef char *general_string;\n\n"
105 "typedef char *general_string;\n\n"
112#endif
113 );
114 fprintf (headerfile,
115 "typedef struct oid {\n"
116 " size_t length;\n"
117 " unsigned *components;\n"
118 "} oid;\n\n");
106 );
107 fprintf (headerfile,
108 "typedef struct oid {\n"
109 " size_t length;\n"
110 " unsigned *components;\n"
111 "} oid;\n\n");
112 fputs("#define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \\\n"
113 " do { \\\n"
114 " (BL) = length_##T((S)); \\\n"
115 " (B) = malloc((BL)); \\\n"
116 " if((B) == NULL) { \\\n"
117 " (R) = ENOMEM; \\\n"
118 " } else { \\\n"
119 " (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \\\n"
120 " (S), (L)); \\\n"
121 " if((R) != 0) { \\\n"
122 " free((B)); \\\n"
123 " (B) = NULL; \\\n"
124 " } \\\n"
125 " } \\\n"
126 " } while (0)\n\n",
127 headerfile);
119 fprintf (headerfile, "#endif\n\n");
120 logfile = fopen(STEM "_files", "w");
121 if (logfile == NULL)
122 err (1, "open " STEM "_files");
123}
124
125void
126close_generate (void)
127{
128 fprintf (headerfile, "#endif /* __%s_h__ */\n", headerbase);
129
130 fclose (headerfile);
131 fprintf (logfile, "\n");
132 fclose (logfile);
133}
134
135void
136generate_constant (const Symbol *s)
137{
138 fprintf (headerfile, "enum { %s = %d };\n\n",
139 s->gen_name, s->constant);
140}
141
142static void
143space(int level)
144{
145 while(level-- > 0)
146 fprintf(headerfile, " ");
147}
148
149static void
150define_asn1 (int level, Type *t)
151{
152 switch (t->type) {
153 case TType:
154 space(level);
155 fprintf (headerfile, "%s", t->symbol->name);
156 break;
157 case TInteger:
158 space(level);
159 fprintf (headerfile, "INTEGER");
160 break;
161 case TUInteger:
162 space(level);
163 fprintf (headerfile, "UNSIGNED INTEGER");
164 break;
165 case TOctetString:
166 space(level);
167 fprintf (headerfile, "OCTET STRING");
168 break;
169 case TOID :
170 space(level);
171 fprintf(headerfile, "OBJECT IDENTIFIER");
172 break;
173 case TBitString: {
174 Member *m;
175 int tag = -1;
176
177 space(level);
178 fprintf (headerfile, "BIT STRING {\n");
179 for (m = t->members; m && m->val != tag; m = m->next) {
180 if (tag == -1)
181 tag = m->val;
182 space(level + 1);
183 fprintf (headerfile, "%s(%d)%s\n", m->name, m->val,
184 m->next->val == tag?"":",");
185
186 }
187 space(level);
188 fprintf (headerfile, "}");
189 break;
190 }
191 case TEnumerated : {
192 Member *m;
193 int tag = -1;
194
195 space(level);
196 fprintf (headerfile, "ENUMERATED {\n");
197 for (m = t->members; m && m->val != tag; m = m->next) {
198 if (tag == -1)
199 tag = m->val;
200 space(level + 1);
201 fprintf (headerfile, "%s(%d)%s\n", m->name, m->val,
202 m->next->val == tag?"":",");
203
204 }
205 space(level);
206 fprintf (headerfile, "}");
207 break;
208 }
209 case TSequence: {
210 Member *m;
211 int tag;
212 int max_width = 0;
213
214 space(level);
215 fprintf (headerfile, "SEQUENCE {\n");
216 for (m = t->members, tag = -1; m && m->val != tag; m = m->next) {
217 if (tag == -1)
218 tag = m->val;
219 if(strlen(m->name) + (m->val > 9) > max_width)
220 max_width = strlen(m->name) + (m->val > 9);
221 }
222 max_width += 3 + 2;
223 if(max_width < 16) max_width = 16;
224 for (m = t->members, tag = -1 ; m && m->val != tag; m = m->next) {
225 int width;
226 if (tag == -1)
227 tag = m->val;
228 space(level + 1);
229 fprintf(headerfile, "%s[%d]", m->name, m->val);
230 width = max_width - strlen(m->name) - 3 - (m->val > 9) - 2;
231 fprintf(headerfile, "%*s", width, "");
232 define_asn1(level + 1, m->type);
233 if(m->optional)
234 fprintf(headerfile, " OPTIONAL");
235 if(m->next->val != tag)
236 fprintf (headerfile, ",");
237 fprintf (headerfile, "\n");
238 }
239 space(level);
240 fprintf (headerfile, "}");
241 break;
242 }
243 case TSequenceOf: {
244 space(level);
245 fprintf (headerfile, "SEQUENCE OF ");
246 define_asn1 (0, t->subtype);
247 break;
248 }
249 case TGeneralizedTime:
250 space(level);
251 fprintf (headerfile, "GeneralizedTime");
252 break;
253 case TGeneralString:
254 space(level);
255 fprintf (headerfile, "GeneralString");
256 break;
257 case TApplication:
258 fprintf (headerfile, "[APPLICATION %d] ", t->application);
259 define_asn1 (level, t->subtype);
260 break;
261 default:
262 abort ();
263 }
264}
265
266static void
267define_type (int level, char *name, Type *t, int typedefp)
268{
269 switch (t->type) {
270 case TType:
271 space(level);
272 fprintf (headerfile, "%s %s;\n", t->symbol->gen_name, name);
273 break;
274 case TInteger:
275 space(level);
276 if(t->members == NULL) {
277 fprintf (headerfile, "int %s;\n", name);
278 } else {
279 Member *m;
280 int tag = -1;
281 fprintf (headerfile, "enum %s {\n", typedefp ? name : "");
282 for (m = t->members; m && m->val != tag; m = m->next) {
283 if(tag == -1)
284 tag = m->val;
285 space (level + 1);
286 fprintf(headerfile, "%s = %d%s\n", m->gen_name, m->val,
287 m->next->val == tag ? "" : ",");
288 }
289 fprintf (headerfile, "} %s;\n", name);
290 }
291 break;
292 case TUInteger:
293 space(level);
294 fprintf (headerfile, "unsigned int %s;\n", name);
295 break;
296 case TOctetString:
297 space(level);
298 fprintf (headerfile, "octet_string %s;\n", name);
299 break;
300 case TOID :
301 space(level);
302 fprintf (headerfile, "oid %s;\n", name);
303 break;
304 case TBitString: {
305 Member *m;
306 Type i;
307 int tag = -1;
308
309 i.type = TUInteger;
310 space(level);
311 fprintf (headerfile, "struct %s {\n", typedefp ? name : "");
312 for (m = t->members; m && m->val != tag; m = m->next) {
313 char *n;
314
315 asprintf (&n, "%s:1", m->gen_name);
316 define_type (level + 1, n, &i, FALSE);
317 free (n);
318 if (tag == -1)
319 tag = m->val;
320 }
321 space(level);
322 fprintf (headerfile, "} %s;\n\n", name);
323 break;
324 }
325 case TEnumerated: {
326 Member *m;
327 int tag = -1;
328
329 space(level);
330 fprintf (headerfile, "enum %s {\n", typedefp ? name : "");
331 for (m = t->members; m && m->val != tag; m = m->next) {
332 if (tag == -1)
333 tag = m->val;
334 space(level + 1);
335 fprintf (headerfile, "%s = %d%s\n", m->gen_name, m->val,
336 m->next->val == tag ? "" : ",");
337 }
338 space(level);
339 fprintf (headerfile, "} %s;\n\n", name);
340 break;
341 }
342 case TSequence: {
343 Member *m;
344 int tag = -1;
345
346 space(level);
347 fprintf (headerfile, "struct %s {\n", typedefp ? name : "");
348 for (m = t->members; m && m->val != tag; m = m->next) {
349 if (m->optional) {
350 char *n;
351
352 asprintf (&n, "*%s", m->gen_name);
353 define_type (level + 1, n, m->type, FALSE);
354 free (n);
355 } else
356 define_type (level + 1, m->gen_name, m->type, FALSE);
357 if (tag == -1)
358 tag = m->val;
359 }
360 space(level);
361 fprintf (headerfile, "} %s;\n", name);
362 break;
363 }
364 case TSequenceOf: {
365 Type i;
366
367 i.type = TUInteger;
368 i.application = 0;
369
370 space(level);
371 fprintf (headerfile, "struct %s {\n", typedefp ? name : "");
372 define_type (level + 1, "len", &i, FALSE);
373 define_type (level + 1, "*val", t->subtype, FALSE);
374 space(level);
375 fprintf (headerfile, "} %s;\n", name);
376 break;
377 }
378 case TGeneralizedTime:
379 space(level);
380 fprintf (headerfile, "time_t %s;\n", name);
381 break;
382 case TGeneralString:
383 space(level);
384 fprintf (headerfile, "general_string %s;\n", name);
385 break;
386 case TApplication:
387 define_type (level, name, t->subtype, FALSE);
388 break;
389 default:
390 abort ();
391 }
392}
393
394static void
395generate_type_header (const Symbol *s)
396{
397 fprintf (headerfile, "/*\n");
398 fprintf (headerfile, "%s ::= ", s->name);
399 define_asn1 (0, s->type);
400 fprintf (headerfile, "\n*/\n\n");
401
402 fprintf (headerfile, "typedef ");
403 define_type (0, s->gen_name, s->type, TRUE);
404
405 fprintf (headerfile, "\n");
406}
407
408
409void
410generate_type (const Symbol *s)
411{
412 struct import *i;
413 char *filename;
414
415 asprintf (&filename, "%s_%s.x", STEM, s->gen_name);
416 codefile = fopen (filename, "w");
417 if (codefile == NULL)
418 err (1, "fopen %s", filename);
419 fprintf(logfile, "%s ", filename);
420 free(filename);
421 fprintf (codefile,
422 "/* Generated from %s */\n"
423 "/* Do not edit */\n\n"
424 "#include <stdio.h>\n"
425 "#include <stdlib.h>\n"
426 "#include <time.h>\n"
427 "#include <string.h>\n"
428 "#include <errno.h>\n",
429 orig_filename);
430
431 for (i = imports; i != NULL; i = i->next)
432 fprintf (codefile,
433 "#include <%s_asn1.h>\n",
434 i->module);
435 fprintf (codefile,
436 "#include <%s.h>\n",
437 headerbase);
438 fprintf (codefile,
439 "#include <asn1_err.h>\n"
440 "#include <der.h>\n"
441 "#include <parse_units.h>\n\n");
442 generate_type_header (s);
443 generate_type_encode (s);
444 generate_type_decode (s);
445 generate_type_free (s);
446 generate_type_length (s);
447 generate_type_copy (s);
448 generate_glue (s);
449 fprintf(headerfile, "\n\n");
450 fclose(codefile);
451}
128 fprintf (headerfile, "#endif\n\n");
129 logfile = fopen(STEM "_files", "w");
130 if (logfile == NULL)
131 err (1, "open " STEM "_files");
132}
133
134void
135close_generate (void)
136{
137 fprintf (headerfile, "#endif /* __%s_h__ */\n", headerbase);
138
139 fclose (headerfile);
140 fprintf (logfile, "\n");
141 fclose (logfile);
142}
143
144void
145generate_constant (const Symbol *s)
146{
147 fprintf (headerfile, "enum { %s = %d };\n\n",
148 s->gen_name, s->constant);
149}
150
151static void
152space(int level)
153{
154 while(level-- > 0)
155 fprintf(headerfile, " ");
156}
157
158static void
159define_asn1 (int level, Type *t)
160{
161 switch (t->type) {
162 case TType:
163 space(level);
164 fprintf (headerfile, "%s", t->symbol->name);
165 break;
166 case TInteger:
167 space(level);
168 fprintf (headerfile, "INTEGER");
169 break;
170 case TUInteger:
171 space(level);
172 fprintf (headerfile, "UNSIGNED INTEGER");
173 break;
174 case TOctetString:
175 space(level);
176 fprintf (headerfile, "OCTET STRING");
177 break;
178 case TOID :
179 space(level);
180 fprintf(headerfile, "OBJECT IDENTIFIER");
181 break;
182 case TBitString: {
183 Member *m;
184 int tag = -1;
185
186 space(level);
187 fprintf (headerfile, "BIT STRING {\n");
188 for (m = t->members; m && m->val != tag; m = m->next) {
189 if (tag == -1)
190 tag = m->val;
191 space(level + 1);
192 fprintf (headerfile, "%s(%d)%s\n", m->name, m->val,
193 m->next->val == tag?"":",");
194
195 }
196 space(level);
197 fprintf (headerfile, "}");
198 break;
199 }
200 case TEnumerated : {
201 Member *m;
202 int tag = -1;
203
204 space(level);
205 fprintf (headerfile, "ENUMERATED {\n");
206 for (m = t->members; m && m->val != tag; m = m->next) {
207 if (tag == -1)
208 tag = m->val;
209 space(level + 1);
210 fprintf (headerfile, "%s(%d)%s\n", m->name, m->val,
211 m->next->val == tag?"":",");
212
213 }
214 space(level);
215 fprintf (headerfile, "}");
216 break;
217 }
218 case TSequence: {
219 Member *m;
220 int tag;
221 int max_width = 0;
222
223 space(level);
224 fprintf (headerfile, "SEQUENCE {\n");
225 for (m = t->members, tag = -1; m && m->val != tag; m = m->next) {
226 if (tag == -1)
227 tag = m->val;
228 if(strlen(m->name) + (m->val > 9) > max_width)
229 max_width = strlen(m->name) + (m->val > 9);
230 }
231 max_width += 3 + 2;
232 if(max_width < 16) max_width = 16;
233 for (m = t->members, tag = -1 ; m && m->val != tag; m = m->next) {
234 int width;
235 if (tag == -1)
236 tag = m->val;
237 space(level + 1);
238 fprintf(headerfile, "%s[%d]", m->name, m->val);
239 width = max_width - strlen(m->name) - 3 - (m->val > 9) - 2;
240 fprintf(headerfile, "%*s", width, "");
241 define_asn1(level + 1, m->type);
242 if(m->optional)
243 fprintf(headerfile, " OPTIONAL");
244 if(m->next->val != tag)
245 fprintf (headerfile, ",");
246 fprintf (headerfile, "\n");
247 }
248 space(level);
249 fprintf (headerfile, "}");
250 break;
251 }
252 case TSequenceOf: {
253 space(level);
254 fprintf (headerfile, "SEQUENCE OF ");
255 define_asn1 (0, t->subtype);
256 break;
257 }
258 case TGeneralizedTime:
259 space(level);
260 fprintf (headerfile, "GeneralizedTime");
261 break;
262 case TGeneralString:
263 space(level);
264 fprintf (headerfile, "GeneralString");
265 break;
266 case TApplication:
267 fprintf (headerfile, "[APPLICATION %d] ", t->application);
268 define_asn1 (level, t->subtype);
269 break;
270 default:
271 abort ();
272 }
273}
274
275static void
276define_type (int level, char *name, Type *t, int typedefp)
277{
278 switch (t->type) {
279 case TType:
280 space(level);
281 fprintf (headerfile, "%s %s;\n", t->symbol->gen_name, name);
282 break;
283 case TInteger:
284 space(level);
285 if(t->members == NULL) {
286 fprintf (headerfile, "int %s;\n", name);
287 } else {
288 Member *m;
289 int tag = -1;
290 fprintf (headerfile, "enum %s {\n", typedefp ? name : "");
291 for (m = t->members; m && m->val != tag; m = m->next) {
292 if(tag == -1)
293 tag = m->val;
294 space (level + 1);
295 fprintf(headerfile, "%s = %d%s\n", m->gen_name, m->val,
296 m->next->val == tag ? "" : ",");
297 }
298 fprintf (headerfile, "} %s;\n", name);
299 }
300 break;
301 case TUInteger:
302 space(level);
303 fprintf (headerfile, "unsigned int %s;\n", name);
304 break;
305 case TOctetString:
306 space(level);
307 fprintf (headerfile, "octet_string %s;\n", name);
308 break;
309 case TOID :
310 space(level);
311 fprintf (headerfile, "oid %s;\n", name);
312 break;
313 case TBitString: {
314 Member *m;
315 Type i;
316 int tag = -1;
317
318 i.type = TUInteger;
319 space(level);
320 fprintf (headerfile, "struct %s {\n", typedefp ? name : "");
321 for (m = t->members; m && m->val != tag; m = m->next) {
322 char *n;
323
324 asprintf (&n, "%s:1", m->gen_name);
325 define_type (level + 1, n, &i, FALSE);
326 free (n);
327 if (tag == -1)
328 tag = m->val;
329 }
330 space(level);
331 fprintf (headerfile, "} %s;\n\n", name);
332 break;
333 }
334 case TEnumerated: {
335 Member *m;
336 int tag = -1;
337
338 space(level);
339 fprintf (headerfile, "enum %s {\n", typedefp ? name : "");
340 for (m = t->members; m && m->val != tag; m = m->next) {
341 if (tag == -1)
342 tag = m->val;
343 space(level + 1);
344 fprintf (headerfile, "%s = %d%s\n", m->gen_name, m->val,
345 m->next->val == tag ? "" : ",");
346 }
347 space(level);
348 fprintf (headerfile, "} %s;\n\n", name);
349 break;
350 }
351 case TSequence: {
352 Member *m;
353 int tag = -1;
354
355 space(level);
356 fprintf (headerfile, "struct %s {\n", typedefp ? name : "");
357 for (m = t->members; m && m->val != tag; m = m->next) {
358 if (m->optional) {
359 char *n;
360
361 asprintf (&n, "*%s", m->gen_name);
362 define_type (level + 1, n, m->type, FALSE);
363 free (n);
364 } else
365 define_type (level + 1, m->gen_name, m->type, FALSE);
366 if (tag == -1)
367 tag = m->val;
368 }
369 space(level);
370 fprintf (headerfile, "} %s;\n", name);
371 break;
372 }
373 case TSequenceOf: {
374 Type i;
375
376 i.type = TUInteger;
377 i.application = 0;
378
379 space(level);
380 fprintf (headerfile, "struct %s {\n", typedefp ? name : "");
381 define_type (level + 1, "len", &i, FALSE);
382 define_type (level + 1, "*val", t->subtype, FALSE);
383 space(level);
384 fprintf (headerfile, "} %s;\n", name);
385 break;
386 }
387 case TGeneralizedTime:
388 space(level);
389 fprintf (headerfile, "time_t %s;\n", name);
390 break;
391 case TGeneralString:
392 space(level);
393 fprintf (headerfile, "general_string %s;\n", name);
394 break;
395 case TApplication:
396 define_type (level, name, t->subtype, FALSE);
397 break;
398 default:
399 abort ();
400 }
401}
402
403static void
404generate_type_header (const Symbol *s)
405{
406 fprintf (headerfile, "/*\n");
407 fprintf (headerfile, "%s ::= ", s->name);
408 define_asn1 (0, s->type);
409 fprintf (headerfile, "\n*/\n\n");
410
411 fprintf (headerfile, "typedef ");
412 define_type (0, s->gen_name, s->type, TRUE);
413
414 fprintf (headerfile, "\n");
415}
416
417
418void
419generate_type (const Symbol *s)
420{
421 struct import *i;
422 char *filename;
423
424 asprintf (&filename, "%s_%s.x", STEM, s->gen_name);
425 codefile = fopen (filename, "w");
426 if (codefile == NULL)
427 err (1, "fopen %s", filename);
428 fprintf(logfile, "%s ", filename);
429 free(filename);
430 fprintf (codefile,
431 "/* Generated from %s */\n"
432 "/* Do not edit */\n\n"
433 "#include <stdio.h>\n"
434 "#include <stdlib.h>\n"
435 "#include <time.h>\n"
436 "#include <string.h>\n"
437 "#include <errno.h>\n",
438 orig_filename);
439
440 for (i = imports; i != NULL; i = i->next)
441 fprintf (codefile,
442 "#include <%s_asn1.h>\n",
443 i->module);
444 fprintf (codefile,
445 "#include <%s.h>\n",
446 headerbase);
447 fprintf (codefile,
448 "#include <asn1_err.h>\n"
449 "#include <der.h>\n"
450 "#include <parse_units.h>\n\n");
451 generate_type_header (s);
452 generate_type_encode (s);
453 generate_type_decode (s);
454 generate_type_free (s);
455 generate_type_length (s);
456 generate_type_copy (s);
457 generate_glue (s);
458 fprintf(headerfile, "\n\n");
459 fclose(codefile);
460}