crypto/external/bsd/heimdal/dist/lib/asn1/asn1parse.y

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