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