source: heimdal/trunk/lib/asn1/asn1parse.y@ 4

Last change on this file since 4 was 1, checked in by Paul Smedley, 10 years ago

Initial commit of Heimdal 1.5.3
File size: 20.9 KB
Line 
1/*
2 * Copyright (c) 1997 - 2007 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/* $Id$ */
37
38%{
39
40#include <config.h>
41
42#include <stdio.h>
43#include <stdlib.h>
44#include <string.h>
45#include "symbol.h"
46#include "lex.h"
47#include "gen_locl.h"
48#include "der.h"
49
50RCSID("$Id$");
51
52static Type *new_type (Typetype t);
53static struct constraint_spec *new_constraint_spec(enum ctype);
54static Type *new_tag(int tagclass, int tagvalue, int tagenv, Type *oldtype);
55void yyerror (const char *);
56static struct objid *new_objid(const char *label, int value);
57static void add_oid_to_tail(struct objid *, struct objid *);
58static void fix_labels(Symbol *s);
59
60struct string_list {
61 char *string;
62 struct string_list *next;
63};
64
65/* Declarations for Bison */
66#define YYMALLOC malloc
67#define YYFREE free
68
69%}
70
71%union {
72 int constant;
73 struct value *value;
74 struct range *range;
75 char *name;
76 Type *type;
77 Member *member;
78 struct objid *objid;
79 char *defval;
80 struct string_list *sl;
81 struct tagtype tag;
82 struct memhead *members;
83 struct constraint_spec *constraint_spec;
84}
85
86%token kw_ABSENT
87%token kw_ABSTRACT_SYNTAX
88%token kw_ALL
89%token kw_APPLICATION
90%token kw_AUTOMATIC
91%token kw_BEGIN
92%token kw_BIT
93%token kw_BMPString
94%token kw_BOOLEAN
95%token kw_BY
96%token kw_CHARACTER
97%token kw_CHOICE
98%token kw_CLASS
99%token kw_COMPONENT
100%token kw_COMPONENTS
101%token kw_CONSTRAINED
102%token kw_CONTAINING
103%token kw_DEFAULT
104%token kw_DEFINITIONS
105%token kw_EMBEDDED
106%token kw_ENCODED
107%token kw_END
108%token kw_ENUMERATED
109%token kw_EXCEPT
110%token kw_EXPLICIT
111%token kw_EXPORTS
112%token kw_EXTENSIBILITY
113%token kw_EXTERNAL
114%token kw_FALSE
115%token kw_FROM
116%token kw_GeneralString
117%token kw_GeneralizedTime
118%token kw_GraphicString
119%token kw_IA5String
120%token kw_IDENTIFIER
121%token kw_IMPLICIT
122%token kw_IMPLIED
123%token kw_IMPORTS
124%token kw_INCLUDES
125%token kw_INSTANCE
126%token kw_INTEGER
127%token kw_INTERSECTION
128%token kw_ISO646String
129%token kw_MAX
130%token kw_MIN
131%token kw_MINUS_INFINITY
132%token kw_NULL
133%token kw_NumericString
134%token kw_OBJECT
135%token kw_OCTET
136%token kw_OF
137%token kw_OPTIONAL
138%token kw_ObjectDescriptor
139%token kw_PATTERN
140%token kw_PDV
141%token kw_PLUS_INFINITY
142%token kw_PRESENT
143%token kw_PRIVATE
144%token kw_PrintableString
145%token kw_REAL
146%token kw_RELATIVE_OID
147%token kw_SEQUENCE
148%token kw_SET
149%token kw_SIZE
150%token kw_STRING
151%token kw_SYNTAX
152%token kw_T61String
153%token kw_TAGS
154%token kw_TRUE
155%token kw_TYPE_IDENTIFIER
156%token kw_TeletexString
157%token kw_UNION
158%token kw_UNIQUE
159%token kw_UNIVERSAL
160%token kw_UTCTime
161%token kw_UTF8String
162%token kw_UniversalString
163%token kw_VideotexString
164%token kw_VisibleString
165%token kw_WITH
166
167%token RANGE
168%token EEQUAL
169%token ELLIPSIS
170
171%token <name> IDENTIFIER referencename
172%token <name> STRING
173
174%token <constant> NUMBER
175%type <constant> SignedNumber
176%type <constant> Class tagenv
177
178%type <value> Value
179%type <value> BuiltinValue
180%type <value> IntegerValue
181%type <value> BooleanValue
182%type <value> ObjectIdentifierValue
183%type <value> CharacterStringValue
184%type <value> NullValue
185%type <value> DefinedValue
186%type <value> ReferencedValue
187%type <value> Valuereference
188
189%type <type> Type
190%type <type> BuiltinType
191%type <type> BitStringType
192%type <type> BooleanType
193%type <type> ChoiceType
194%type <type> ConstrainedType
195%type <type> EnumeratedType
196%type <type> IntegerType
197%type <type> NullType
198%type <type> OctetStringType
199%type <type> SequenceType
200%type <type> SequenceOfType
201%type <type> SetType
202%type <type> SetOfType
203%type <type> TaggedType
204%type <type> ReferencedType
205%type <type> DefinedType
206%type <type> UsefulType
207%type <type> ObjectIdentifierType
208%type <type> CharacterStringType
209%type <type> RestrictedCharactedStringType
210
211%type <tag> Tag
212
213%type <member> ComponentType
214%type <member> NamedBit
215%type <member> NamedNumber
216%type <member> NamedType
217%type <members> ComponentTypeList
218%type <members> Enumerations
219%type <members> NamedBitList
220%type <members> NamedNumberList
221
222%type <objid> objid objid_list objid_element objid_opt
223%type <range> range size
224
225%type <sl> referencenames
226
227%type <constraint_spec> Constraint
228%type <constraint_spec> ConstraintSpec
229%type <constraint_spec> GeneralConstraint
230%type <constraint_spec> ContentsConstraint
231%type <constraint_spec> UserDefinedConstraint
232
233
234
235%start ModuleDefinition
236
237%%
238
239ModuleDefinition: IDENTIFIER objid_opt kw_DEFINITIONS TagDefault ExtensionDefault
240 EEQUAL kw_BEGIN ModuleBody kw_END
241 {
242 checkundefined();
243 }
244 ;
245
246TagDefault : kw_EXPLICIT kw_TAGS
247 | kw_IMPLICIT kw_TAGS
248 { lex_error_message("implicit tagging is not supported"); }
249 | kw_AUTOMATIC kw_TAGS
250 { lex_error_message("automatic tagging is not supported"); }
251 | /* empty */
252 ;
253
254ExtensionDefault: kw_EXTENSIBILITY kw_IMPLIED
255 { lex_error_message("no extensibility options supported"); }
256 | /* empty */
257 ;
258
259ModuleBody : Exports Imports AssignmentList
260 | /* empty */
261 ;
262
263Imports : kw_IMPORTS SymbolsImported ';'
264 | /* empty */
265 ;
266
267SymbolsImported : SymbolsFromModuleList
268 | /* empty */
269 ;
270
271SymbolsFromModuleList: SymbolsFromModule
272 | SymbolsFromModuleList SymbolsFromModule
273 ;
274
275SymbolsFromModule: referencenames kw_FROM IDENTIFIER objid_opt
276 {
277 struct string_list *sl;
278 for(sl = $1; sl != NULL; sl = sl->next) {
279 Symbol *s = addsym(sl->string);
280 s->stype = Stype;
281 gen_template_import(s);
282 }
283 add_import($3);
284 }
285 ;
286
287Exports : kw_EXPORTS referencenames ';'
288 {
289 struct string_list *sl;
290 for(sl = $2; sl != NULL; sl = sl->next)
291 add_export(sl->string);
292 }
293 | kw_EXPORTS kw_ALL
294 | /* empty */
295 ;
296
297AssignmentList : Assignment
298 | Assignment AssignmentList
299 ;
300
301Assignment : TypeAssignment
302 | ValueAssignment
303 ;
304
305referencenames : IDENTIFIER ',' referencenames
306 {
307 $$ = emalloc(sizeof(*$$));
308 $$->string = $1;
309 $$->next = $3;
310 }
311 | IDENTIFIER
312 {
313 $$ = emalloc(sizeof(*$$));
314 $$->string = $1;
315 $$->next = NULL;
316 }
317 ;
318
319TypeAssignment : IDENTIFIER EEQUAL Type
320 {
321 Symbol *s = addsym ($1);
322 s->stype = Stype;
323 s->type = $3;
324 fix_labels(s);
325 generate_type (s);
326 }
327 ;
328
329Type : BuiltinType
330 | ReferencedType
331 | ConstrainedType
332 ;
333
334BuiltinType : BitStringType
335 | BooleanType
336 | CharacterStringType
337 | ChoiceType
338 | EnumeratedType
339 | IntegerType
340 | NullType
341 | ObjectIdentifierType
342 | OctetStringType
343 | SequenceType
344 | SequenceOfType
345 | SetType
346 | SetOfType
347 | TaggedType
348 ;
349
350BooleanType : kw_BOOLEAN
351 {
352 $$ = new_tag(ASN1_C_UNIV, UT_Boolean,
353 TE_EXPLICIT, new_type(TBoolean));
354 }
355 ;
356
357range : '(' Value RANGE Value ')'
358 {
359 if($2->type != integervalue)
360 lex_error_message("Non-integer used in first part of range");
361 if($2->type != integervalue)
362 lex_error_message("Non-integer in second part of range");
363 $$ = ecalloc(1, sizeof(*$$));
364 $$->min = $2->u.integervalue;
365 $$->max = $4->u.integervalue;
366 }
367 | '(' Value RANGE kw_MAX ')'
368 {
369 if($2->type != integervalue)
370 lex_error_message("Non-integer in first part of range");
371 $$ = ecalloc(1, sizeof(*$$));
372 $$->min = $2->u.integervalue;
373 $$->max = $2->u.integervalue - 1;
374 }
375 | '(' kw_MIN RANGE Value ')'
376 {
377 if($4->type != integervalue)
378 lex_error_message("Non-integer in second part of range");
379 $$ = ecalloc(1, sizeof(*$$));
380 $$->min = $4->u.integervalue + 2;
381 $$->max = $4->u.integervalue;
382 }
383 | '(' Value ')'
384 {
385 if($2->type != integervalue)
386 lex_error_message("Non-integer used in limit");
387 $$ = ecalloc(1, sizeof(*$$));
388 $$->min = $2->u.integervalue;
389 $$->max = $2->u.integervalue;
390 }
391 ;
392
393
394IntegerType : kw_INTEGER
395 {
396 $$ = new_tag(ASN1_C_UNIV, UT_Integer,
397 TE_EXPLICIT, new_type(TInteger));
398 }
399 | kw_INTEGER range
400 {
401 $$ = new_type(TInteger);
402 $$->range = $2;
403 $$ = new_tag(ASN1_C_UNIV, UT_Integer, TE_EXPLICIT, $$);
404 }
405 | kw_INTEGER '{' NamedNumberList '}'
406 {
407 $$ = new_type(TInteger);
408 $$->members = $3;
409 $$ = new_tag(ASN1_C_UNIV, UT_Integer, TE_EXPLICIT, $$);
410 }
411 ;
412
413NamedNumberList : NamedNumber
414 {
415 $$ = emalloc(sizeof(*$$));
416 ASN1_TAILQ_INIT($$);
417 ASN1_TAILQ_INSERT_HEAD($$, $1, members);
418 }
419 | NamedNumberList ',' NamedNumber
420 {
421 ASN1_TAILQ_INSERT_TAIL($1, $3, members);
422 $$ = $1;
423 }
424 | NamedNumberList ',' ELLIPSIS
425 { $$ = $1; } /* XXX used for Enumerations */
426 ;
427
428NamedNumber : IDENTIFIER '(' SignedNumber ')'
429 {
430 $$ = emalloc(sizeof(*$$));
431 $$->name = $1;
432 $$->gen_name = estrdup($1);
433 output_name ($$->gen_name);
434 $$->val = $3;
435 $$->optional = 0;
436 $$->ellipsis = 0;
437 $$->type = NULL;
438 }
439 ;
440
441EnumeratedType : kw_ENUMERATED '{' Enumerations '}'
442 {
443 $$ = new_type(TInteger);
444 $$->members = $3;
445 $$ = new_tag(ASN1_C_UNIV, UT_Enumerated, TE_EXPLICIT, $$);
446 }
447 ;
448
449Enumerations : NamedNumberList /* XXX */
450 ;
451
452BitStringType : kw_BIT kw_STRING
453 {
454 $$ = new_type(TBitString);
455 $$->members = emalloc(sizeof(*$$->members));
456 ASN1_TAILQ_INIT($$->members);
457 $$ = new_tag(ASN1_C_UNIV, UT_BitString, TE_EXPLICIT, $$);
458 }
459 | kw_BIT kw_STRING '{' NamedBitList '}'
460 {
461 $$ = new_type(TBitString);
462 $$->members = $4;
463 $$ = new_tag(ASN1_C_UNIV, UT_BitString, TE_EXPLICIT, $$);
464 }
465 ;
466
467ObjectIdentifierType: kw_OBJECT kw_IDENTIFIER
468 {
469 $$ = new_tag(ASN1_C_UNIV, UT_OID,
470 TE_EXPLICIT, new_type(TOID));
471 }
472 ;
473OctetStringType : kw_OCTET kw_STRING size
474 {
475 Type *t = new_type(TOctetString);
476 t->range = $3;
477 $$ = new_tag(ASN1_C_UNIV, UT_OctetString,
478 TE_EXPLICIT, t);
479 }
480 ;
481
482NullType : kw_NULL
483 {
484 $$ = new_tag(ASN1_C_UNIV, UT_Null,
485 TE_EXPLICIT, new_type(TNull));
486 }
487 ;
488
489size :
490 { $$ = NULL; }
491 | kw_SIZE range
492 { $$ = $2; }
493 ;
494
495
496SequenceType : kw_SEQUENCE '{' /* ComponentTypeLists */ ComponentTypeList '}'
497 {
498 $$ = new_type(TSequence);
499 $$->members = $3;
500 $$ = new_tag(ASN1_C_UNIV, UT_Sequence, TE_EXPLICIT, $$);
501 }
502 | kw_SEQUENCE '{' '}'
503 {
504 $$ = new_type(TSequence);
505 $$->members = NULL;
506 $$ = new_tag(ASN1_C_UNIV, UT_Sequence, TE_EXPLICIT, $$);
507 }
508 ;
509
510SequenceOfType : kw_SEQUENCE size kw_OF Type
511 {
512 $$ = new_type(TSequenceOf);
513 $$->range = $2;
514 $$->subtype = $4;
515 $$ = new_tag(ASN1_C_UNIV, UT_Sequence, TE_EXPLICIT, $$);
516 }
517 ;
518
519SetType : kw_SET '{' /* ComponentTypeLists */ ComponentTypeList '}'
520 {
521 $$ = new_type(TSet);
522 $$->members = $3;
523 $$ = new_tag(ASN1_C_UNIV, UT_Set, TE_EXPLICIT, $$);
524 }
525 | kw_SET '{' '}'
526 {
527 $$ = new_type(TSet);
528 $$->members = NULL;
529 $$ = new_tag(ASN1_C_UNIV, UT_Set, TE_EXPLICIT, $$);
530 }
531 ;
532
533SetOfType : kw_SET kw_OF Type
534 {
535 $$ = new_type(TSetOf);
536 $$->subtype = $3;
537 $$ = new_tag(ASN1_C_UNIV, UT_Set, TE_EXPLICIT, $$);
538 }
539 ;
540
541ChoiceType : kw_CHOICE '{' /* AlternativeTypeLists */ ComponentTypeList '}'
542 {
543 $$ = new_type(TChoice);
544 $$->members = $3;
545 }
546 ;
547
548ReferencedType : DefinedType
549 | UsefulType
550 ;
551
552DefinedType : IDENTIFIER
553 {
554 Symbol *s = addsym($1);
555 $$ = new_type(TType);
556 if(s->stype != Stype && s->stype != SUndefined)
557 lex_error_message ("%s is not a type\n", $1);
558 else
559 $$->symbol = s;
560 }
561 ;
562
563UsefulType : kw_GeneralizedTime
564 {
565 $$ = new_tag(ASN1_C_UNIV, UT_GeneralizedTime,
566 TE_EXPLICIT, new_type(TGeneralizedTime));
567 }
568 | kw_UTCTime
569 {
570 $$ = new_tag(ASN1_C_UNIV, UT_UTCTime,
571 TE_EXPLICIT, new_type(TUTCTime));
572 }
573 ;
574
575ConstrainedType : Type Constraint
576 {
577 /* if (Constraint.type == contentConstrant) {
578 assert(Constraint.u.constraint.type == octetstring|bitstring-w/o-NamedBitList); // remember to check type reference too
579 if (Constraint.u.constraint.type) {
580 assert((Constraint.u.constraint.type.length % 8) == 0);
581 }
582 }
583 if (Constraint.u.constraint.encoding) {
584 type == der-oid|ber-oid
585 }
586 */
587 }
588 ;
589
590
591Constraint : '(' ConstraintSpec ')'
592 {
593 $$ = $2;
594 }
595 ;
596
597ConstraintSpec : GeneralConstraint
598 ;
599
600GeneralConstraint: ContentsConstraint
601 | UserDefinedConstraint
602 ;
603
604ContentsConstraint: kw_CONTAINING Type
605 {
606 $$ = new_constraint_spec(CT_CONTENTS);
607 $$->u.content.type = $2;
608 $$->u.content.encoding = NULL;
609 }
610 | kw_ENCODED kw_BY Value
611 {
612 if ($3->type != objectidentifiervalue)
613 lex_error_message("Non-OID used in ENCODED BY constraint");
614 $$ = new_constraint_spec(CT_CONTENTS);
615 $$->u.content.type = NULL;
616 $$->u.content.encoding = $3;
617 }
618 | kw_CONTAINING Type kw_ENCODED kw_BY Value
619 {
620 if ($5->type != objectidentifiervalue)
621 lex_error_message("Non-OID used in ENCODED BY constraint");
622 $$ = new_constraint_spec(CT_CONTENTS);
623 $$->u.content.type = $2;
624 $$->u.content.encoding = $5;
625 }
626 ;
627
628UserDefinedConstraint: kw_CONSTRAINED kw_BY '{' '}'
629 {
630 $$ = new_constraint_spec(CT_USER);
631 }
632 ;
633
634TaggedType : Tag tagenv Type
635 {
636 $$ = new_type(TTag);
637 $$->tag = $1;
638 $$->tag.tagenv = $2;
639 if($3->type == TTag && $2 == TE_IMPLICIT) {
640 $$->subtype = $3->subtype;
641 free($3);
642 } else
643 $$->subtype = $3;
644 }
645 ;
646
647Tag : '[' Class NUMBER ']'
648 {
649 $$.tagclass = $2;
650 $$.tagvalue = $3;
651 $$.tagenv = TE_EXPLICIT;
652 }
653 ;
654
655Class : /* */
656 {
657 $$ = ASN1_C_CONTEXT;
658 }
659 | kw_UNIVERSAL
660 {
661 $$ = ASN1_C_UNIV;
662 }
663 | kw_APPLICATION
664 {
665 $$ = ASN1_C_APPL;
666 }
667 | kw_PRIVATE
668 {
669 $$ = ASN1_C_PRIVATE;
670 }
671 ;
672
673tagenv : /* */
674 {
675 $$ = TE_EXPLICIT;
676 }
677 | kw_EXPLICIT
678 {
679 $$ = TE_EXPLICIT;
680 }
681 | kw_IMPLICIT
682 {
683 $$ = TE_IMPLICIT;
684 }
685 ;
686
687
688ValueAssignment : IDENTIFIER Type EEQUAL Value
689 {
690 Symbol *s;
691 s = addsym ($1);
692
693 s->stype = SValue;
694 s->value = $4;
695 generate_constant (s);
696 }
697 ;
698
699CharacterStringType: RestrictedCharactedStringType
700 ;
701
702RestrictedCharactedStringType: kw_GeneralString
703 {
704 $$ = new_tag(ASN1_C_UNIV, UT_GeneralString,
705 TE_EXPLICIT, new_type(TGeneralString));
706 }
707 | kw_TeletexString
708 {
709 $$ = new_tag(ASN1_C_UNIV, UT_TeletexString,
710 TE_EXPLICIT, new_type(TTeletexString));
711 }
712 | kw_UTF8String
713 {
714 $$ = new_tag(ASN1_C_UNIV, UT_UTF8String,
715 TE_EXPLICIT, new_type(TUTF8String));
716 }
717 | kw_PrintableString
718 {
719 $$ = new_tag(ASN1_C_UNIV, UT_PrintableString,
720 TE_EXPLICIT, new_type(TPrintableString));
721 }
722 | kw_VisibleString
723 {
724 $$ = new_tag(ASN1_C_UNIV, UT_VisibleString,
725 TE_EXPLICIT, new_type(TVisibleString));
726 }
727 | kw_IA5String
728 {
729 $$ = new_tag(ASN1_C_UNIV, UT_IA5String,
730 TE_EXPLICIT, new_type(TIA5String));
731 }
732 | kw_BMPString
733 {
734 $$ = new_tag(ASN1_C_UNIV, UT_BMPString,
735 TE_EXPLICIT, new_type(TBMPString));
736 }
737 | kw_UniversalString
738 {
739 $$ = new_tag(ASN1_C_UNIV, UT_UniversalString,
740 TE_EXPLICIT, new_type(TUniversalString));
741 }
742
743 ;
744
745ComponentTypeList: ComponentType
746 {
747 $$ = emalloc(sizeof(*$$));
748 ASN1_TAILQ_INIT($$);
749 ASN1_TAILQ_INSERT_HEAD($$, $1, members);
750 }
751 | ComponentTypeList ',' ComponentType
752 {
753 ASN1_TAILQ_INSERT_TAIL($1, $3, members);
754 $$ = $1;
755 }
756 | ComponentTypeList ',' ELLIPSIS
757 {
758 struct member *m = ecalloc(1, sizeof(*m));
759 m->name = estrdup("...");
760 m->gen_name = estrdup("asn1_ellipsis");
761 m->ellipsis = 1;
762 ASN1_TAILQ_INSERT_TAIL($1, m, members);
763 $$ = $1;
764 }
765 ;
766
767NamedType : IDENTIFIER Type
768 {
769 $$ = emalloc(sizeof(*$$));
770 $$->name = $1;
771 $$->gen_name = estrdup($1);
772 output_name ($$->gen_name);
773 $$->type = $2;
774 $$->ellipsis = 0;
775 }
776 ;
777
778ComponentType : NamedType
779 {
780 $$ = $1;
781 $$->optional = 0;
782 $$->defval = NULL;
783 }
784 | NamedType kw_OPTIONAL
785 {
786 $$ = $1;
787 $$->optional = 1;
788 $$->defval = NULL;
789 }
790 | NamedType kw_DEFAULT Value
791 {
792 $$ = $1;
793 $$->optional = 0;
794 $$->defval = $3;
795 }
796 ;
797
798NamedBitList : NamedBit
799 {
800 $$ = emalloc(sizeof(*$$));
801 ASN1_TAILQ_INIT($$);
802 ASN1_TAILQ_INSERT_HEAD($$, $1, members);
803 }
804 | NamedBitList ',' NamedBit
805 {
806 ASN1_TAILQ_INSERT_TAIL($1, $3, members);
807 $$ = $1;
808 }
809 ;
810
811NamedBit : IDENTIFIER '(' NUMBER ')'
812 {
813 $$ = emalloc(sizeof(*$$));
814 $$->name = $1;
815 $$->gen_name = estrdup($1);
816 output_name ($$->gen_name);
817 $$->val = $3;
818 $$->optional = 0;
819 $$->ellipsis = 0;
820 $$->type = NULL;
821 }
822 ;
823
824objid_opt : objid
825 | /* empty */ { $$ = NULL; }
826 ;
827
828objid : '{' objid_list '}'
829 {
830 $$ = $2;
831 }
832 ;
833
834objid_list : /* empty */
835 {
836 $$ = NULL;
837 }
838 | objid_element objid_list
839 {
840 if ($2) {
841 $$ = $2;
842 add_oid_to_tail($2, $1);
843 } else {
844 $$ = $1;
845 }
846 }
847 ;
848
849objid_element : IDENTIFIER '(' NUMBER ')'
850 {
851 $$ = new_objid($1, $3);
852 }
853 | IDENTIFIER
854 {
855 Symbol *s = addsym($1);
856 if(s->stype != SValue ||
857 s->value->type != objectidentifiervalue) {
858 lex_error_message("%s is not an object identifier\n",
859 s->name);
860 exit(1);
861 }
862 $$ = s->value->u.objectidentifiervalue;
863 }
864 | NUMBER
865 {
866 $$ = new_objid(NULL, $1);
867 }
868 ;
869
870Value : BuiltinValue
871 | ReferencedValue
872 ;
873
874BuiltinValue : BooleanValue
875 | CharacterStringValue
876 | IntegerValue
877 | ObjectIdentifierValue
878 | NullValue
879 ;
880
881ReferencedValue : DefinedValue
882 ;
883
884DefinedValue : Valuereference
885 ;
886
887Valuereference : IDENTIFIER
888 {
889 Symbol *s = addsym($1);
890 if(s->stype != SValue)
891 lex_error_message ("%s is not a value\n",
892 s->name);
893 else
894 $$ = s->value;
895 }
896 ;
897
898CharacterStringValue: STRING
899 {
900 $$ = emalloc(sizeof(*$$));
901 $$->type = stringvalue;
902 $$->u.stringvalue = $1;
903 }
904 ;
905
906BooleanValue : kw_TRUE
907 {
908 $$ = emalloc(sizeof(*$$));
909 $$->type = booleanvalue;
910 $$->u.booleanvalue = 0;
911 }
912 | kw_FALSE
913 {
914 $$ = emalloc(sizeof(*$$));
915 $$->type = booleanvalue;
916 $$->u.booleanvalue = 0;
917 }
918 ;
919
920IntegerValue : SignedNumber
921 {
922 $$ = emalloc(sizeof(*$$));
923 $$->type = integervalue;
924 $$->u.integervalue = $1;
925 }
926 ;
927
928SignedNumber : NUMBER
929 ;
930
931NullValue : kw_NULL
932 {
933 }
934 ;
935
936ObjectIdentifierValue: objid
937 {
938 $$ = emalloc(sizeof(*$$));
939 $$->type = objectidentifiervalue;
940 $$->u.objectidentifiervalue = $1;
941 }
942 ;
943
944%%
945
946void
947yyerror (const char *s)
948{
949 lex_error_message ("%s\n", s);
950}
951
952static Type *
953new_tag(int tagclass, int tagvalue, int tagenv, Type *oldtype)
954{
955 Type *t;
956 if(oldtype->type == TTag && oldtype->tag.tagenv == TE_IMPLICIT) {
957 t = oldtype;
958 oldtype = oldtype->subtype; /* XXX */
959 } else
960 t = new_type (TTag);
961
962 t->tag.tagclass = tagclass;
963 t->tag.tagvalue = tagvalue;
964 t->tag.tagenv = tagenv;
965 t->subtype = oldtype;
966 return t;
967}
968
969static struct objid *
970new_objid(const char *label, int value)
971{
972 struct objid *s;
973 s = emalloc(sizeof(*s));
974 s->label = label;
975 s->value = value;
976 s->next = NULL;
977 return s;
978}
979
980static void
981add_oid_to_tail(struct objid *head, struct objid *tail)
982{
983 struct objid *o;
984 o = head;
985 while (o->next)
986 o = o->next;
987 o->next = tail;
988}
989
990static Type *
991new_type (Typetype tt)
992{
993 Type *t = ecalloc(1, sizeof(*t));
994 t->type = tt;
995 return t;
996}
997
998static struct constraint_spec *
999new_constraint_spec(enum ctype ct)
1000{
1001 struct constraint_spec *c = ecalloc(1, sizeof(*c));
1002 c->ctype = ct;
1003 return c;
1004}
1005
1006static void fix_labels2(Type *t, const char *prefix);
1007static void fix_labels1(struct memhead *members, const char *prefix)
1008{
1009 Member *m;
1010
1011 if(members == NULL)
1012 return;
1013 ASN1_TAILQ_FOREACH(m, members, members) {
1014 if (asprintf(&m->label, "%s_%s", prefix, m->gen_name) < 0)
1015 errx(1, "malloc");
1016 if (m->label == NULL)
1017 errx(1, "malloc");
1018 if(m->type != NULL)
1019 fix_labels2(m->type, m->label);
1020 }
1021}
1022
1023static void fix_labels2(Type *t, const char *prefix)
1024{
1025 for(; t; t = t->subtype)
1026 fix_labels1(t->members, prefix);
1027}
1028
1029static void
1030fix_labels(Symbol *s)
1031{
1032 char *p = NULL;
1033 if (asprintf(&p, "choice_%s", s->gen_name) < 0 || p == NULL)
1034 errx(1, "malloc");
1035 fix_labels2(s->type, p);
1036 free(p);
1037}
Note: See TracBrowser for help on using the repository browser.