tools/asnparser/asn_grammar.y

   1 %expect 14
   2
   3 %{
   4
   5 /*
   6  * asn_grammar.y
   7  *
   8  * ASN grammar file
   9  *
  10  * ASN.1 compiler to produce C++ classes.
  11  *
  12  * Copyright (c) 1997-1999 Equivalence Pty. Ltd.
  13  *
  14  * The contents of this file are subject to the Mozilla Public License
  15  * Version 1.0 (the "License"); you may not use this file except in
  16  * compliance with the License. You may obtain a copy of the License at
  17  * http://www.mozilla.org/MPL/
  18  *
  19  * Software distributed under the License is distributed on an "AS IS"
  20  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  21  * the License for the specific language governing rights and limitations
  22  * under the License.
  23  *
  24  * The Original Code is ASN Parser.
  25  *
  26  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  27  *
  28  * Portions of this code were written with the assisance of funding from
  29  * Vovida Networks, Inc. http://www.vovida.com.
  30  *
  31  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  32  * All Rights Reserved.
  33  *
  34  * Contributor(s): ______________________________________.
  35  *
  36  * $Log$
  37  * Revision 1.13  2004/04/03 08:22:23  csoutheren
  38  * Remove pseudo-RTTI and replaced with real RTTI
  39  *
  40  * Revision 1.12  2001/10/02 00:56:04  robertj
  41  * Fixed problem with autonumering enumerated types.
  42  *
  43  * Revision 1.11  2001/01/16 14:00:17  craigs
  44  * Changed MIN and MAX tokens to avoid namespace conflicts under BeOS
  45  *
  46  * Revision 1.10  2000/05/08 08:55:44  robertj
  47  * Fixed production error for ValueSet, thanks Huang-Ming Huang
  48  *
  49  * Revision 1.9  2000/01/19 12:33:07  robertj
  50  * Fixed parsing of OID's in IMPORTS section.
  51  *
  52  * Revision 1.8  2000/01/19 03:38:12  robertj
  53  * Fixed support for parsing multiple IMPORTS
  54  *
  55  * Revision 1.7  1999/07/22 06:48:54  robertj
  56  * Added comparison operation to base ASN classes and compiled ASN code.
  57  * Added support for ANY type in ASN parser.
  58  *
  59  * Revision 1.6  1999/06/09 06:58:08  robertj
  60  * Adjusted heading comments.
  61  *
  62  * Revision 1.5  1999/06/07 01:56:25  robertj
  63  * Added header comment on license.
  64  *
  65  * Revision 1.4  1999/06/06 05:30:28  robertj
  66  * Support for parameterised types and type-dentifier types.
  67  * Added ability to output multiple .cxx files.
  68  *
  69  * Revision 1.3  1998/12/14 06:47:55  robertj
  70  * New memory check code support.
  71  *
  72  * Revision 1.2  1998/05/21 04:21:46  robertj
  73  * Implementing more of the ASN spec.
  74  *
  75  * Revision 1.1  1997/12/13 09:17:47  robertj
  76  * Initial revision
  77  *
  78  */
  79
  80 #include <ptlib.h>
  81
  82 #undef malloc
  83 #undef calloc
  84 #undef realloc
  85 #undef free
  86
  87 #include "main.h"
  88
  89 extern int yylex();
  90
  91 extern int ReferenceTokenContext;
  92 extern int IdentifierTokenContext;
  93 extern int BraceTokenContext;
  94 extern int NullTokenContext;
  95 extern int InMacroContext;
  96 extern int HasObjectTypeMacro;
  97 extern int InMIBContext;
  98 extern TypesList * CurrentImportList;
  99
 100 static int UnnamedFieldCount = 1;
 101 static PStringList * DummyParameters;
 102
 103 static PString * ConcatNames(PString * s1, char c, PString * s2)
 104 {
 105   *s1 += c;
 106   *s1 += *s2;
 107   delete s2;
 108   return s1;
 109 }
 110
 111 #ifdef _MSC_VER
 112 #pragma warning(disable:4701)
 113 #endif
 114
 115 %}
 116
 117 %token IDENTIFIER
 118 %token BIT_IDENTIFIER
 119 %token OID_IDENTIFIER
 120 %token IMPORT_IDENTIFIER
 121 %token MODULEREFERENCE
 122 %token TYPEREFERENCE
 123 %token OBJECTCLASSREFERENCE
 124 %token TYPEFIELDREFERENCE
 125 %token VALUEFIELDREFERENCE
 126 %token VALUESETFIELDREFERENCE
 127 %token OBJECTFIELDREFERENCE
 128 %token OBJECTSETFIELDREFERENCE
 129 %token OBJECTREFERENCE
 130 %token OBJECTSETREFERENCE
 131 %token INTEGER
 132
 133 %token CSTRING
 134 %token OS_BSTRING
 135 %token BS_BSTRING
 136 %token OS_HSTRING
 137 %token BS_HSTRING
 138
 139 %token STRING_BRACE
 140 %token BITSTRING_BRACE
 141 %token OID_BRACE
 142
 143 %token ABSENT
 144 %token ABSTRACT_SYNTAX
 145 %token ALL
 146 %token ANY
 147 %token APPLICATION
 148 %token ASSIGNMENT
 149 %token AUTOMATIC
 150 %token BEGIN_t
 151 %token BIT
 152 %token BMPString
 153 %token BOOLEAN_t
 154 %token BY
 155 %token CHARACTER
 156 %token CHOICE
 157 %token CLASS
 158 %token COMPONENT
 159 %token COMPONENTS
 160 %token CONSTRAINED
 161 %token DEFAULT
 162 %token DEFINED
 163 %token DEFINITIONS
 164 %token EMBEDDED
 165 %token END
 166 %token ENUMERATED
 167 %token EXCEPT
 168 %token EXPLICIT
 169 %token EXPORTS
 170 %token EXTERNAL
 171 %token FALSE_t
 172 %token FROM
 173 %token GeneralString
 174 %token GraphicString
 175 %token IA5String
 176 %token TYPE_IDENTIFIER
 177 %token IDENTIFIER_t
 178 %token IMPLICIT
 179 %token IMPORTS
 180 %token INCLUDES
 181 %token INSTANCE
 182 %token INTEGER_t
 183 %token INTERSECTION
 184 %token ISO646String
 185 %token MACRO
 186 %token MAX_t
 187 %token MIN_t
 188 %token MINUS_INFINITY
 189 %token NOTATION
 190 %token NULL_VALUE
 191 %token NULL_TYPE
 192 %token NumericString
 193 %token OBJECT
 194 %token OCTET
 195 %token OF_t
 196 %token OPTIONAL_t
 197 %token PDV
 198 %token PLUS_INFINITY
 199 %token PRESENT
 200 %token PrintableString
 201 %token PRIVATE
 202 %token REAL
 203 %token SEQUENCE
 204 %token SET
 205 %token SIZE_t
 206 %token STRING
 207 %token SYNTAX
 208 %token T61String
 209 %token TAGS
 210 %token TeletexString
 211 %token TRUE_t
 212 %token TYPE_t
 213 %token UNION
 214 %token UNIQUE
 215 %token UNIVERSAL
 216 %token UniversalString
 217 %token VideotexString
 218 %token VisibleString
 219 %token GeneralizedTime
 220 %token UTCTime
 221 %token VALUE
 222 %token WITH
 223 %token string_t
 224 %token identifier_t
 225 %token number_t
 226 %token empty_t
 227 %token type_t
 228 %token value_t
 229 %token OBJECT_TYPE
 230 %token TRAP_TYPE
 231 %token ACCESS
 232 %token STATUS
 233 %token read_only_t
 234 %token read_write_t
 235 %token write_only_t
 236 %token not_accessible_t
 237 %token mandatory_t
 238 %token optional_t
 239 %token obsolete_t
 240 %token deprecated_t
 241 %token DESCRIPTION_t
 242 %token REFERENCE_t
 243 %token INDEX_t
 244 %token DEFVAL_t
 245 %token ENTERPRISE
 246 %token VARIABLES
 247
 248 %token ObjectDescriptor_t
 249
 250
 251 %type <ival> INTEGER
 252 %type <ival> TagDefault
 253 %type <ival> SignedNumber
 254 %type <ival> ObjectTypeAccess ObjectTypeStatus
 255 %type <ival> Class ClassNumber
 256 %type <ival> PresenceConstraint
 257
 258 %type <sval> CSTRING
 259 %type <sval> BS_BSTRING
 260 %type <sval> OS_BSTRING
 261 %type <sval> BS_HSTRING
 262 %type <sval> OS_HSTRING
 263 %type <sval> IDENTIFIER
 264 %type <sval> BIT_IDENTIFIER
 265 %type <sval> OID_IDENTIFIER
 266 %type <sval> IMPORT_IDENTIFIER
 267 %type <sval> TYPEREFERENCE
 268 %type <sval> MODULEREFERENCE
 269 %type <sval> OBJECTCLASSREFERENCE
 270 %type <sval> TYPEFIELDREFERENCE
 271 %type <sval> VALUEFIELDREFERENCE
 272 %type <sval> VALUESETFIELDREFERENCE
 273 %type <sval> OBJECTFIELDREFERENCE
 274 %type <sval> OBJECTSETFIELDREFERENCE
 275 %type <sval> OBJECTREFERENCE
 276 %type <sval> OBJECTSETREFERENCE
 277 %type <sval> DefinitiveObjIdComponent
 278 %type <sval> DefinitiveNameAndNumberForm
 279 %type <sval> GlobalModuleReference
 280 %type <sval> Reference
 281 %type <sval> ExternalTypeReference ExternalValueReference
 282 %type <sval> ObjIdComponent
 283 %type <sval> NumberForm
 284 %type <sval> SimpleDefinedType
 285 %type <sval> ComponentIdList
 286 %type <sval> CharsDefn
 287 %type <sval> SimpleDefinedValue
 288 %type <sval> FieldName PrimitiveFieldName
 289 %type <sval> DefinedObjectClass
 290 %type <sval> ExternalObjectClassReference
 291 %type <sval> UsefulObjectClassReference
 292 %type <sval> Parameter
 293 %type <sval> MibIndexType MibDescrPart MibReferPart
 294
 295 %type <slst> DefinitiveIdentifier
 296 %type <slst> DefinitiveObjIdComponentList
 297 %type <slst> ObjIdComponentList
 298 %type <slst> BitIdentifierList
 299 %type <slst> CharSyms
 300 %type <slst> ParameterList Parameters
 301 %type <slst> MibIndexTypes MibIndexPart
 302
 303 %type <tval> Type BuiltinType ReferencedType NamedType
 304 %type <tval> DefinedType
 305 %type <tval> ConstrainedType
 306 %type <tval> TypeWithConstraint
 307 %type <tval> BitStringType
 308 %type <tval> BooleanType
 309 %type <tval> CharacterStringType
 310 %type <tval> RestrictedCharacterStringType
 311 %type <tval> UnrestrictedCharacterStringType
 312 %type <tval> ChoiceType AlternativeTypeLists
 313 %type <tval> EmbeddedPDVType
 314 %type <tval> EnumeratedType Enumerations
 315 %type <tval> ExternalType
 316 %type <tval> AnyType
 317 %type <tval> IntegerType
 318 %type <tval> NullType
 319 %type <tval> ObjectClassFieldType
 320 %type <tval> ObjectIdentifierType
 321 %type <tval> OctetStringType
 322 %type <tval> RealType
 323 %type <tval> SequenceType ComponentType ComponentTypeLists
 324 %type <tval> SequenceOfType
 325 %type <tval> SetType
 326 %type <tval> SetOfType
 327 %type <tval> TaggedType
 328 %type <tval> ParameterizedType
 329 %type <tval> SelectionType
 330 %type <tval> UsefulType
 331 %type <tval> TypeFromObject
 332 %type <tval> ContainedSubtype
 333 %type <tval> ActualParameter
 334 %type <tval> UserDefinedConstraintParameter
 335 %type <tval> Symbol
 336 %type <tval> ParameterizedReference
 337
 338 %type <tlst> AlternativeTypeList
 339 %type <tlst> ComponentTypeList
 340 %type <tlst> ActualParameterList ActualParameters
 341 %type <tlst> UserDefinedConstraintParameters
 342 %type <tlst> SymbolList
 343
 344 %type <vval> Value BuiltinValue
 345 %type <vval> AssignedIdentifier
 346 %type <vval> DefinedValue DefinedValue_Import
 347 %type <vval> ObjectIdentifierValue
 348 %type <vval> OctetStringValue
 349 %type <vval> BitStringValue
 350 %type <vval> ExceptionSpec
 351 %type <vval> ExceptionIdentification
 352 %type <vval> MibDefValPart
 353 %type <vval> LowerEndpoint LowerEndValue UpperEndpoint UpperEndValue
 354 %type <vval> ReferencedValue
 355 %type <vval> BooleanValue
 356 %type <vval> CharacterStringValue RestrictedCharacterStringValue
 357 %type <vval> CharacterStringList Quadruple Tuple
 358 %type <vval> ChoiceValue
 359 %type <vval> NullValue
 360 %type <vval> RealValue NumericRealValue SpecialRealValue
 361 %type <vval> SequenceValue NamedValue
 362 /*!!!! %type <vval> SequenceOfValue */
 363 %type <vval> ParameterizedValue
 364
 365 %type <vlst> ComponentValueList
 366 %type <vlst> MibVarPart MibVarTypes
 367
 368 %type <nval> NamedBit
 369 %type <nval> EnumerationItem
 370 %type <nval> NamedNumber
 371
 372 %type <nlst> NamedBitList
 373 %type <nlst> Enumeration
 374 %type <nlst> NamedNumberList
 375
 376 %type <elmt> IntersectionElements
 377 %type <elmt> Elements
 378 %type <elmt> Exclusions
 379 %type <elmt> SubtypeElements
 380 %type <elmt> ObjectSetElements
 381 %type <elmt> ValueRange
 382 %type <elmt> PermittedAlphabet
 383 %type <elmt> InnerTypeConstraints
 384 %type <elmt> MultipleTypeConstraints
 385 %type <elmt> SizeConstraint
 386 %type <elmt> UserDefinedConstraintParameterList
 387 %type <elmt> NamedConstraint
 388
 389 %type <elst> ElementSetSpec Unions Intersections TypeConstraints
 390
 391 %type <cons> Constraint
 392 %type <cons> ConstraintSpec
 393 %type <cons> ElementSetSpecs
 394 %type <cons> GeneralConstraint
 395 %type <cons> UserDefinedConstraint
 396 %type <cons> TableConstraint
 397 %type <cons> ComponentRelationConstraint
 398 %type <cons> ObjectSet
 399
 400 %type <tagv> Tag
 401
 402
 403 %union {
 404   PInt64                  ival;
 405   PString               * sval;
 406   PStringList           * slst;
 407   TypeBase              * tval;
 408   TypesList             * tlst;
 409   ValueBase             * vval;
 410   ValuesList            * vlst;
 411   NamedNumber           * nval;
 412   NamedNumberList       * nlst;
 413   Constraint            * cons;
 414   ConstraintElementList * elst;
 415   ConstraintElementBase * elmt;
 416   struct {
 417     Tag::Type tagClass;
 418     unsigned tagNumber;
 419   } tagv;
 420 }
 421
 422
 423 %%
 424
 425 ModuleDefinition
 426   : MODULEREFERENCE DefinitiveIdentifier DEFINITIONS TagDefault ASSIGNMENT BEGIN_t
 427       {
 428         Module = new ModuleDefinition($1, $2, (Tag::Mode)$4);
 429         ReferenceTokenContext = TYPEREFERENCE;
 430       }
 431     ModuleBody END
 432   ;
 433
 434 DefinitiveIdentifier
 435   : '{' DefinitiveObjIdComponentList '}'
 436         {
 437           $$ = $2;
 438         }
 439   | /* empty */
 440         {
 441           $$ = new PStringList;
 442         }
 443   ;
 444
 445 DefinitiveObjIdComponentList
 446   : DefinitiveObjIdComponent
 447       {
 448         $$ = new PStringList;
 449         $$->Append($1);
 450       }
 451   | DefinitiveObjIdComponent DefinitiveObjIdComponentList
 452       {
 453         $2->InsertAt(0, $1);
 454         $$ = $2;
 455       }
 456   ;
 457
 458 DefinitiveObjIdComponent
 459   : IDENTIFIER
 460   | INTEGER
 461       {
 462         $$ = new PString(PString::Unsigned, (int)$1);
 463       }
 464   | DefinitiveNameAndNumberForm
 465   ;
 466
 467 DefinitiveNameAndNumberForm
 468   : IDENTIFIER '(' INTEGER ')'
 469       {
 470         delete $1;
 471         $$ = new PString(PString::Unsigned, (int)$3);
 472       }
 473   ;
 474
 475 TagDefault
 476   : EXPLICIT TAGS
 477       {
 478         $$ = Tag::Explicit;
 479       }
 480   | IMPLICIT TAGS
 481       {
 482         $$ = Tag::Implicit;
 483       }
 484   | AUTOMATIC TAGS
 485       {
 486         $$ = Tag::Automatic;
 487       }
 488   | /* empty */
 489       {
 490         $$ = Tag::Explicit;
 491       }
 492   ;
 493
 494
 495 /*************************************/
 496
 497 ModuleBody
 498   : Exports Imports AssignmentList
 499   | /* empty */
 500   ;
 501
 502
 503 Exports
 504   : EXPORTS SymbolsExported ';'
 505   | /* empty */
 506   ;
 507
 508
 509 SymbolsExported
 510   : SymbolList
 511       {
 512         Module->SetExports($1);
 513       }
 514   | /* empty */
 515       {
 516         Module->SetExportAll();
 517       }
 518   ;
 519
 520
 521 Imports
 522   : IMPORTS SymbolsImported ';'
 523   | /* empty */
 524   ;
 525
 526
 527 SymbolsImported
 528   : SymbolsFromModuleList
 529   | /* empty */
 530   ;
 531
 532 SymbolsFromModuleList
 533   : SymbolsFromModule
 534   | SymbolsFromModuleList SymbolsFromModule
 535   ;
 536
 537
 538 SymbolsFromModule
 539   : SymbolList FROM
 540       {
 541         CurrentImportList = $1;
 542         ReferenceTokenContext = MODULEREFERENCE;
 543       }
 544     GlobalModuleReference
 545       {
 546         if (!HasObjectTypeMacro) {
 547           HasObjectTypeMacro = $1->GetValuesIndex(SearchType("OBJECT-TYPE")) != P_MAX_INDEX;
 548           if (HasObjectTypeMacro)
 549             PError << "Info: including OBJECT-TYPE macro" << endl;
 550         }
 551         Module->AddImport(new ImportModule($4, $1));
 552         ReferenceTokenContext = TYPEREFERENCE;
 553         CurrentImportList = NULL;
 554       }
 555   ;
 556
 557
 558 GlobalModuleReference
 559   : MODULEREFERENCE
 560       {
 561         ReferenceTokenContext = TYPEREFERENCE;
 562         BraceTokenContext = OID_BRACE;
 563       }
 564     AssignedIdentifier
 565       {
 566         BraceTokenContext = '{';
 567         delete $3;
 568       }
 569   ;
 570
 571
 572 AssignedIdentifier
 573   : DefinedValue_Import
 574   | ObjectIdentifierValue
 575   | /* empty */
 576       {
 577         $$ = NULL;
 578       }
 579   ;
 580
 581 DefinedValue_Import
 582   : ExternalValueReference
 583       {
 584         $$ = new DefinedValue($1);
 585       }
 586   | IMPORT_IDENTIFIER
 587       {
 588         $$ = new DefinedValue($1);
 589       }
 590   ;
 591
 592
 593
 594 SymbolList
 595   : Symbol
 596       {
 597         $$ = new TypesList;
 598         $$->Append($1);
 599       }
 600   | Symbol ',' SymbolList
 601       {
 602         $3->Append($1);
 603         $$ = $3;
 604       }
 605   ;
 606
 607
 608 Symbol
 609   : Reference
 610       {
 611         $$ = new ImportedType($1, FALSE);
 612       }
 613   | ParameterizedReference    /* only required for X.683 */
 614   ;
 615
 616
 617 /*************************************/
 618
 619 AssignmentList: Assignment
 620   | AssignmentList Assignment
 621   ;
 622
 623
 624 Assignment
 625   : TypeAssignment
 626   | ValueAssignment
 627   | ValueSetTypeAssignment
 628   | ObjectClassAssignment
 629   | ObjectAssignment
 630   | ObjectSetAssignment
 631   | ParameterizedAssignment
 632   /* We do not have "real" macros, so fake MIB ones */
 633   | MacroDefinition
 634   | ObjectTypeDefinition
 635   | TrapTypeDefinition
 636   ;
 637
 638
 639 ValueSetTypeAssignment
 640   : TYPEREFERENCE Type
 641       {
 642         $2->SetName($1);
 643         Module->AddType($2);
 644         IdentifierTokenContext = $2->GetIdentifierTokenContext();
 645         BraceTokenContext = $2->GetBraceTokenContext();
 646       }
 647     ASSIGNMENT ValueSet
 648       {
 649         IdentifierTokenContext = IDENTIFIER;
 650         BraceTokenContext = '{';
 651       }
 652   ;
 653
 654
 655
 656
 657 /********/
 658
 659 TypeAssignment
 660   : TYPEREFERENCE ASSIGNMENT Type
 661       {
 662         $3->SetName($1);
 663         Module->AddType($3);
 664       }
 665   ;
 666
 667
 668 Type
 669   : ConstrainedType
 670   | ReferencedType
 671   | BuiltinType
 672   ;
 673
 674
 675 BuiltinType
 676   : BitStringType
 677   | BooleanType
 678   | CharacterStringType
 679   | ChoiceType
 680   | EmbeddedPDVType
 681   | EnumeratedType
 682   | ExternalType
 683   | AnyType
 684   | InstanceOfType
 685     { }
 686   | IntegerType
 687   | NullType
 688   | ObjectClassFieldType
 689   | ObjectIdentifierType
 690   | OctetStringType
 691   | RealType
 692   | SequenceType
 693   | SequenceOfType
 694   | SetType
 695   | SetOfType
 696   | TaggedType
 697   ;
 698
 699
 700 ReferencedType
 701   : DefinedType
 702   | UsefulType
 703   | SelectionType
 704   | TypeFromObject
 705 /*!!! syntactically identical to TypeFromObject
 706   | ValueSetFromObjects
 707 */
 708   ;
 709
 710
 711 DefinedType
 712   : ExternalTypeReference
 713       {
 714         $$ = new DefinedType($1, FALSE);
 715       }
 716   | TYPEREFERENCE
 717       {
 718         $$ = new DefinedType($1,
 719                              DummyParameters != NULL &&
 720                              DummyParameters->GetValuesIndex(*$1) != P_MAX_INDEX);
 721       }
 722   | ParameterizedType
 723 /*| ParameterizedValueSetType   synonym for ParameterizedType */
 724   ;
 725
 726
 727 ExternalTypeReference
 728   : MODULEREFERENCE '.' TYPEREFERENCE
 729       {
 730         *$1 += *$3;
 731         delete $3;
 732       }
 733   ;
 734
 735
 736 BitStringType
 737   : BIT STRING
 738       {
 739         $$ = new BitStringType;
 740       }
 741   | BIT STRING '{' NamedBitList '}'
 742       {
 743         $$ = new BitStringType($4);
 744       }
 745   ;
 746
 747
 748 NamedBitList
 749   : NamedBit
 750       {
 751         $$ = new NamedNumberList;
 752         $$->Append($1);
 753       }
 754   | NamedBitList ',' NamedBit
 755       {
 756         $1->InsertAt(0, $3);
 757       }
 758   ;
 759
 760 NamedBit
 761   : IDENTIFIER '(' INTEGER ')'
 762       {
 763         $$ = new NamedNumber($1, (int)$3);
 764       }
 765   | IDENTIFIER '(' DefinedValue ')'
 766       {
 767         $$ = new NamedNumber($1, ((DefinedValue*)$3)->GetReference());
 768         delete $3;
 769       }
 770   ;
 771
 772
 773 BooleanType
 774   : BOOLEAN_t
 775       {
 776         $$ = new BooleanType;
 777       }
 778   ;
 779
 780
 781 CharacterStringType
 782   : RestrictedCharacterStringType
 783   | UnrestrictedCharacterStringType
 784   ;
 785
 786 RestrictedCharacterStringType
 787   : BMPString
 788       {
 789         $$ = new BMPStringType;
 790       }
 791   | GeneralString
 792       {
 793         $$ = new GeneralStringType;
 794       }
 795   | GraphicString
 796       {
 797         $$ = new GraphicStringType;
 798       }
 799   | IA5String
 800       {
 801         $$ = new IA5StringType;
 802       }
 803   | ISO646String
 804       {
 805         $$ = new ISO646StringType;
 806       }
 807   | NumericString
 808       {
 809         $$ = new NumericStringType;
 810       }
 811   | PrintableString
 812       {
 813         $$ = new PrintableStringType;
 814       }
 815   | TeletexString
 816       {
 817         $$ = new TeletexStringType;
 818       }
 819   | T61String
 820       {
 821         $$ = new T61StringType;
 822       }
 823   | UniversalString
 824       {
 825         $$ = new UniversalStringType;
 826       }
 827   | VideotexString
 828       {
 829         $$ = new VideotexStringType;
 830       }
 831   | VisibleString
 832       {
 833         $$ = new VisibleStringType;
 834       }
 835   ;
 836
 837
 838 UnrestrictedCharacterStringType
 839   : CHARACTER STRING
 840       {
 841         $$ = new UnrestrictedCharacterStringType;
 842       }
 843   ;
 844
 845
 846 ChoiceType
 847   : CHOICE '{' AlternativeTypeLists '}'
 848       {
 849         $$ = $3;
 850       }
 851   ;
 852
 853 AlternativeTypeLists
 854   : AlternativeTypeList
 855       {
 856         $$ = new ChoiceType($1);
 857       }
 858   | AlternativeTypeList ',' ExtensionAndException
 859       {
 860         $$ = new ChoiceType($1, TRUE);
 861       }
 862   | AlternativeTypeList ',' ExtensionAndException  ','  AlternativeTypeList
 863       {
 864         $$ = new ChoiceType($1, TRUE, $5);
 865       }
 866   ;
 867
 868 AlternativeTypeList
 869   : NamedType
 870       {
 871         $$ = new TypesList;
 872         $$->Append($1);
 873       }
 874   | AlternativeTypeList ',' NamedType
 875       {
 876         $1->Append($3);
 877       }
 878   ;
 879
 880
 881 ExtensionAndException
 882   : '.' '.' '.' ExceptionSpec
 883   ;
 884
 885
 886 NamedType
 887   : IDENTIFIER Type
 888       {
 889         $2->SetName($1);
 890         $$ = $2;
 891       }
 892   | Type             /* ITU-T Rec. X.680 Appendix H.1 */
 893       {
 894         PError << StdError(Warning) << "unnamed field." << endl;
 895         $1->SetName(new PString(PString::Printf, "_unnamed%u", UnnamedFieldCount++));
 896       }
 897 /*| SelectionType    /* Unnecessary as have rule in Type for this */
 898   ;
 899
 900
 901 EmbeddedPDVType
 902   : EMBEDDED PDV
 903       {
 904         $$ = new EmbeddedPDVType;
 905       }
 906   ;
 907
 908
 909 EnumeratedType
 910   : ENUMERATED '{' Enumerations '}'
 911       {
 912         $$ = $3;
 913       }
 914   ;
 915
 916 Enumerations
 917   : Enumeration
 918       {
 919         $$ = new EnumeratedType($1, FALSE, NULL);
 920       }
 921   | Enumeration  ',' '.' '.' '.'
 922       {
 923         $$ = new EnumeratedType($1, TRUE, NULL);
 924       }
 925   | Enumeration  ',' '.' '.' '.' ',' Enumeration
 926       {
 927         $$ = new EnumeratedType($1, TRUE, $7);
 928       }
 929   ;
 930
 931 Enumeration
 932   : EnumerationItem
 933       {
 934         $$ = new NamedNumberList;
 935         $$->Append($1);
 936       }
 937   | Enumeration ',' EnumerationItem
 938       {
 939         $1->Append($3);
 940         PINDEX sz = $1->GetSize();
 941         if (sz > 1)
 942           $3->SetAutoNumber((*$1)[sz-2]);
 943         $$ = $1;
 944       }
 945   ;
 946
 947 EnumerationItem
 948   : IDENTIFIER
 949       {
 950         $$ = new NamedNumber($1);
 951       }
 952   | NamedNumber
 953   ;
 954
 955
 956 ExternalType
 957   : EXTERNAL
 958       {
 959         $$ = new ExternalType;
 960       }
 961   ;
 962
 963
 964 AnyType
 965   : ANY
 966       {
 967         $$ = new AnyType(NULL);
 968       }
 969   | ANY DEFINED BY IDENTIFIER
 970       {
 971         $$ = new AnyType($4);
 972       }
 973   ;
 974
 975
 976 InstanceOfType
 977   : INSTANCE OF_t DefinedObjectClass
 978   ;
 979
 980
 981 IntegerType
 982   : INTEGER_t
 983       {
 984         $$ = new IntegerType;
 985       }
 986   | INTEGER_t '{' NamedNumberList '}'
 987       {
 988         $$ = new IntegerType($3);
 989       }
 990   ;
 991
 992
 993 NullType
 994   : NULL_TYPE
 995       {
 996         $$ = new NullType;
 997       }
 998   ;
 999
1000
1001 ObjectClassFieldType
1002   : DefinedObjectClass '.' FieldName
1003       {
1004         $$ = new ObjectClassFieldType($1, $3);
1005       }
1006   ;
1007
1008
1009 ObjectIdentifierType
1010   : OBJECT IDENTIFIER_t
1011       {
1012         $$ = new ObjectIdentifierType;
1013       }
1014   ;
1015
1016 OctetStringType
1017   : OCTET STRING
1018       {
1019         $$ = new OctetStringType;
1020       }
1021   ;
1022
1023
1024 RealType
1025   : REAL
1026       {
1027         $$ = new RealType;
1028       }
1029   ;
1030
1031
1032 SequenceType
1033   : SEQUENCE '{' ComponentTypeLists '}'
1034       {
1035         $$ = $3;
1036       }
1037   | SEQUENCE '{'  '}'
1038       {
1039         $$ = new SequenceType(NULL, FALSE, NULL);
1040       }
1041   | SEQUENCE '{' ExtensionAndException '}'
1042       {
1043         $$ = new SequenceType(NULL, TRUE, NULL);
1044       }
1045   ;
1046
1047 ComponentTypeLists
1048   : ComponentTypeList
1049       {
1050         $$ = new SequenceType($1, FALSE, NULL);
1051       }
1052   | ComponentTypeList ',' ExtensionAndException
1053       {
1054         $$ = new SequenceType($1, TRUE, NULL);
1055       }
1056   | ComponentTypeList ',' ExtensionAndException ',' ComponentTypeList
1057       {
1058         $$ = new SequenceType($1, TRUE, $5);
1059       }
1060   | ExtensionAndException ',' ComponentTypeList
1061       {
1062         $$ = new SequenceType(NULL, TRUE, $3);
1063       }
1064   ;
1065
1066 ComponentTypeList
1067   : ComponentType
1068       {
1069         $$ = new TypesList;
1070         $$->Append($1);
1071       }
1072   | ComponentTypeList ',' ComponentType
1073       {
1074         $1->Append($3);
1075       }
1076   ;
1077
1078 ComponentType
1079   : NamedType
1080   | NamedType OPTIONAL_t
1081       {
1082         $1->SetOptional();
1083       }
1084   | NamedType DEFAULT
1085       {
1086         IdentifierTokenContext = $1->GetIdentifierTokenContext();
1087       }
1088     Value
1089       {
1090         IdentifierTokenContext = IDENTIFIER;
1091         $1->SetDefaultValue($4);
1092       }
1093   | COMPONENTS OF_t Type
1094       {
1095         $$ = $3;
1096       }
1097   ;
1098
1099
1100 SequenceOfType
1101   : SEQUENCE OF_t Type
1102       {
1103         $$ = new SequenceOfType($3, NULL);
1104       }
1105   ;
1106
1107
1108 SetType
1109   : SET '{' ComponentTypeLists '}'
1110       {
1111         $$ = new SetType((SequenceType*)$3);
1112       }
1113   | SET '{'  '}'
1114       {
1115         $$ = new SetType;
1116       }
1117   ;
1118
1119
1120 SetOfType
1121   : SET OF_t Type
1122       {
1123         $$ = new SetOfType($3, NULL);
1124       }
1125   ;
1126
1127
1128 TaggedType
1129   : Tag Type
1130       {
1131         $2->SetTag($1.tagClass, $1.tagNumber, Module->GetDefaultTagMode());
1132         $$ = $2;
1133       }
1134   | Tag IMPLICIT Type
1135       {
1136         $3->SetTag($1.tagClass, $1.tagNumber, Tag::Implicit);
1137         $$ = $3;
1138       }
1139   | Tag EXPLICIT Type
1140       {
1141         $3->SetTag($1.tagClass, $1.tagNumber, Tag::Explicit);
1142         $$ = $3;
1143       }
1144   ;
1145
1146 Tag
1147   : '[' Class ClassNumber ']'
1148       {
1149         $$.tagClass = (Tag::Type)$2;
1150         $$.tagNumber = (int)$3;
1151       }
1152   ;
1153
1154 ClassNumber
1155   : INTEGER
1156   | DefinedValue
1157       {
1158         if (PIsDescendant($1, IntegerValue))
1159           $$ = *(IntegerValue*)$1;
1160         else
1161           PError << StdError(Fatal) << "incorrect value type." << endl;
1162       }
1163   ;
1164
1165 Class
1166   : UNIVERSAL
1167       {
1168         $$ = Tag::Universal;
1169       }
1170   | APPLICATION
1171       {
1172         $$ = Tag::Application;
1173       }
1174   | PRIVATE
1175       {
1176         $$ = Tag::Private;
1177       }
1178   | /* empty */
1179       {
1180         $$ = Tag::ContextSpecific;
1181       }
1182   ;
1183
1184
1185 SelectionType
1186   : IDENTIFIER '<' Type
1187       {
1188         $$ = new SelectionType($1, $3);
1189       }
1190   ;
1191
1192
1193 UsefulType
1194   : GeneralizedTime
1195       {
1196         $$ = new GeneralizedTimeType;
1197       }
1198   | UTCTime
1199       {
1200         $$ = new UTCTimeType;
1201       }
1202   | ObjectDescriptor_t
1203       {
1204         $$ = new ObjectDescriptorType;
1205       }
1206   ;
1207
1208
1209 TypeFromObject
1210   : ReferencedObjects '.' FieldName
1211     { }
1212   ;
1213
1214 /*!!!
1215 ValueSetFromObjects
1216   : ReferencedObjects '.' FieldName
1217   ;
1218 */
1219
1220 ReferencedObjects
1221   : DefinedObject
1222   | ParameterizedObject
1223   | DefinedObjectSet
1224     { }
1225   | ParameterizedObjectSet
1226     { }
1227   ;
1228
1229 ParameterizedObject
1230   : DefinedObject ActualParameterList
1231   ;
1232
1233
1234
1235 /********/
1236
1237 ConstrainedType
1238   : Type Constraint
1239       {
1240         $1->AddConstraint($2);
1241       }
1242   | TypeWithConstraint
1243   ;
1244
1245 TypeWithConstraint
1246   : SET Constraint OF_t Type
1247       {
1248         $$ = new SetOfType($4, $2);
1249       }
1250   | SET SizeConstraint OF_t Type
1251       {
1252         $$ = new SetOfType($4, new Constraint($2));
1253       }
1254   | SEQUENCE Constraint OF_t Type
1255       {
1256         $$ = new SequenceOfType($4, $2);
1257       }
1258   | SEQUENCE SizeConstraint OF_t Type
1259       {
1260         $$ = new SequenceOfType($4, new Constraint($2));
1261       }
1262   ;
1263
1264 Constraint
1265   : '(' ConstraintSpec ExceptionSpec ')'
1266       {
1267         $$ = $2;
1268       }
1269   ;
1270
1271 ConstraintSpec
1272   : ElementSetSpecs
1273   | GeneralConstraint
1274   ;
1275
1276
1277 ExceptionSpec
1278   : '!' ExceptionIdentification
1279       {
1280         $$ = $2;
1281       }
1282   | /* empty */
1283       {
1284         $$ = NULL;
1285       }
1286   ;
1287
1288
1289 ExceptionIdentification
1290   : SignedNumber
1291       {
1292         $$ = new IntegerValue($1);
1293       }
1294   | DefinedValue
1295   | Type ':' Value
1296       {
1297         delete $1;
1298         PError << StdError(Warning) << "Typed exception unsupported" << endl;
1299         $$ = $3;
1300       }
1301   ;
1302
1303
1304 ElementSetSpecs
1305   : ElementSetSpec
1306       {
1307         $$ = new Constraint($1, FALSE, NULL);
1308       }
1309   | ElementSetSpec  ',' '.' '.' '.'
1310       {
1311         $$ = new Constraint($1, TRUE, NULL);
1312       }
1313   | '.' '.' '.' ',' ElementSetSpec
1314       {
1315         $$ = new Constraint(NULL, TRUE, $5);
1316       }
1317   | ElementSetSpec  ',' '.' '.' '.' ElementSetSpec
1318       {
1319         $$ = new Constraint($1, TRUE, $6);
1320       }
1321   ;
1322
1323
1324 ElementSetSpec
1325   : Unions
1326   | ALL Exclusions
1327       {
1328         $$ = new ConstraintElementList;
1329         $$->Append(new ConstrainAllConstraintElement($2));
1330       }
1331   ;
1332
1333
1334 Unions
1335   : Intersections
1336       {
1337         $$ = new ConstraintElementList;
1338         $$->Append(new ElementListConstraintElement($1));
1339       }
1340   | Unions UnionMark Intersections
1341       {
1342         $1->Append(new ElementListConstraintElement($3));
1343       }
1344   ;
1345
1346 Intersections
1347   : IntersectionElements
1348       {
1349         $$ = new ConstraintElementList;
1350         $$->Append($1);
1351       }
1352   | Intersections IntersectionMark IntersectionElements
1353       {
1354         $1->Append($3);
1355       }
1356   ;
1357
1358 IntersectionElements
1359   : Elements
1360   | Elements Exclusions
1361       {
1362         $1->SetExclusions($2);
1363       }
1364   ;
1365
1366 Exclusions
1367   : EXCEPT Elements
1368       {
1369         $$ = $2;
1370       }
1371   ;
1372
1373 UnionMark
1374   : '|'
1375   | UNION
1376   ;
1377
1378 IntersectionMark
1379   : '^'
1380   | INTERSECTION
1381   ;
1382
1383 Elements
1384   : SubtypeElements
1385   | ObjectSetElements
1386   | '(' ElementSetSpec ')'
1387       {
1388         $$ = new ElementListConstraintElement($2);
1389       }
1390   ;
1391
1392
1393 SubtypeElements
1394   : Value
1395       {
1396         $$ = new SingleValueConstraintElement($1);
1397       }
1398   | ContainedSubtype
1399       {
1400         $$ = new SubTypeConstraintElement($1);
1401       }
1402   | ValueRange
1403   | PermittedAlphabet
1404   | SizeConstraint
1405 /*| TypeConstraint  This is really Type and causes ambiguity with ContainedSubtype */
1406   | InnerTypeConstraints
1407   ;
1408
1409 ValueRange
1410   : LowerEndpoint '.' '.' UpperEndpoint
1411       {
1412         $$ = new ValueRangeConstraintElement($1, $4);
1413       }
1414   ;
1415
1416 LowerEndpoint
1417   : LowerEndValue
1418   | LowerEndValue '<'
1419   ;
1420
1421 UpperEndpoint
1422   : UpperEndValue
1423   | '<' UpperEndValue
1424       {
1425         $$ = $2;
1426       }
1427   ;
1428
1429 LowerEndValue
1430   : Value
1431   | MIN_t
1432       {
1433         $$ = new MinValue;
1434       }
1435   ;
1436
1437 UpperEndValue
1438   : Value
1439   | MAX_t
1440       {
1441         $$ = new MaxValue;
1442       }
1443   ;
1444
1445 PermittedAlphabet
1446   : FROM Constraint
1447       {
1448         $$ = new FromConstraintElement($2);
1449       }
1450   ;
1451
1452 ContainedSubtype
1453   : INCLUDES Type
1454       {
1455         $$ = $2;
1456       }
1457 /*| Type         Actual grammar has INCLUDES keyword optional but this is
1458                  horribly ambiguous, so only support  a few specific Type
1459                  definitions */
1460   | ConstrainedType
1461   | BuiltinType
1462   | DefinedType
1463   | UsefulType
1464   ;
1465
1466
1467 SizeConstraint
1468   : SIZE_t Constraint
1469       {
1470         $$ = new SizeConstraintElement($2);
1471       }
1472   ;
1473
1474
1475 InnerTypeConstraints
1476   : WITH COMPONENT Constraint
1477       {
1478         $$ = new WithComponentConstraintElement(NULL, $3, WithComponentConstraintElement::Default);
1479       }
1480   | WITH COMPONENTS MultipleTypeConstraints
1481       {
1482         $$ = $3;
1483       }
1484   ;
1485
1486 MultipleTypeConstraints
1487   : '{' TypeConstraints '}'                     /* FullSpecification */
1488       {
1489         $$ = new InnerTypeConstraintElement($2, FALSE);
1490       }
1491   | '{'  '.' '.' '.' ',' TypeConstraints '}'    /* PartialSpecification */
1492       {
1493         $$ = new InnerTypeConstraintElement($6, TRUE);
1494       }
1495   ;
1496
1497 TypeConstraints
1498   : NamedConstraint
1499       {
1500         $$ = new ConstraintElementList;
1501         $$->Append($1);
1502       }
1503   | NamedConstraint ',' TypeConstraints
1504       {
1505         $3->Append($1);
1506         $$ = $3;
1507       }
1508   ;
1509
1510 NamedConstraint
1511   : IDENTIFIER PresenceConstraint
1512       {
1513         $$ = new WithComponentConstraintElement($1, NULL, (int)$2);
1514       }
1515   | IDENTIFIER Constraint PresenceConstraint
1516       {
1517         $$ = new WithComponentConstraintElement($1, $2, (int)$3);
1518       }
1519   ;
1520
1521 PresenceConstraint
1522   : PRESENT
1523       {
1524         $$ = WithComponentConstraintElement::Present;
1525       }
1526   | ABSENT
1527       {
1528         $$ = WithComponentConstraintElement::Absent;
1529       }
1530   | OPTIONAL_t
1531       {
1532         $$ = WithComponentConstraintElement::Optional;
1533       }
1534   | /* empty */
1535       {
1536         $$ = WithComponentConstraintElement::Default;
1537       }
1538   ;
1539
1540
1541 GeneralConstraint
1542   : UserDefinedConstraint
1543   | TableConstraint
1544   ;
1545
1546 UserDefinedConstraint
1547   : CONSTRAINED BY '{' UserDefinedConstraintParameterList '}'
1548     {
1549       $$ = new Constraint($4);
1550     }
1551   ;
1552
1553 UserDefinedConstraintParameterList
1554   : /* empty */
1555       {
1556         $$ = new UserDefinedConstraintElement(NULL);
1557       }
1558   | UserDefinedConstraintParameters
1559       {
1560         $$ = new UserDefinedConstraintElement($1);
1561       }
1562   ;
1563
1564 UserDefinedConstraintParameters
1565   : UserDefinedConstraintParameter ',' UserDefinedConstraintParameters
1566       {
1567         $3->Append($1);
1568         $$ = $3;
1569       }
1570   | UserDefinedConstraintParameter
1571       {
1572         $$ = new TypesList;
1573         $$->Append($1);
1574       }
1575   ;
1576
1577 UserDefinedConstraintParameter
1578   : Governor ':' ActualParameter
1579       {
1580         $$ = $3;
1581       }
1582   | ActualParameter
1583   ;
1584
1585
1586 TableConstraint
1587   : ObjectSet /* SimpleTableConstraint */
1588   | ComponentRelationConstraint
1589   ;
1590
1591 ComponentRelationConstraint
1592   : '{' DefinedObjectSet '}' '{' AtNotations '}'
1593     { $$ = NULL; }
1594   ;
1595
1596 AtNotations
1597   : AtNotations ',' AtNotation
1598   | AtNotation
1599   ;
1600
1601 AtNotation
1602   : '@' ComponentIdList
1603   | '@' '.' ComponentIdList
1604   ;
1605
1606 ComponentIdList
1607   : ComponentIdList '.' IDENTIFIER
1608   | IDENTIFIER
1609   ;
1610
1611
1612 /********/
1613
1614 ObjectClassAssignment
1615   : OBJECTCLASSREFERENCE ASSIGNMENT ObjectClass
1616     { }
1617   ;
1618
1619 ObjectAssignment
1620   : OBJECTREFERENCE DefinedObjectClass ASSIGNMENT Object
1621     { }
1622   ;
1623
1624 ObjectSetAssignment
1625   : OBJECTSETREFERENCE DefinedObjectClass ASSIGNMENT ObjectSet
1626     { }
1627   ;
1628
1629
1630 ObjectClass
1631   : DefinedObjectClass
1632     { }
1633   | ObjectClassDefn
1634   | ParameterizedObjectClass
1635   ;
1636
1637 DefinedObjectClass
1638   : ExternalObjectClassReference
1639   | OBJECTCLASSREFERENCE
1640   | UsefulObjectClassReference
1641   ;
1642
1643
1644 ExternalObjectClassReference
1645   : MODULEREFERENCE '.' OBJECTCLASSREFERENCE
1646       {
1647         $$ = ConcatNames($1, '.', $3);
1648       }
1649   ;
1650
1651 UsefulObjectClassReference
1652   : TYPE_IDENTIFIER
1653       {
1654         $$ = new PString("TYPE-IDENTIFIER");
1655       }
1656   | ABSTRACT_SYNTAX
1657       {
1658         $$ = new PString("ABSTRACT-SYNTAX");
1659       }
1660   ;
1661
1662
1663 ObjectClassDefn
1664   : CLASS  '{'  FieldSpecs '}'  WithSyntaxSpec
1665   ;
1666
1667 FieldSpecs
1668   : FieldSpecs ',' FieldSpec
1669   | FieldSpec
1670   ;
1671
1672 FieldSpec
1673   : TypeFieldSpec
1674   | FixedTypeValueFieldSpec
1675   | VariableTypeValueFieldSpec
1676   | FixedTypeValueSetFieldSpec
1677   | VariableTypeValueSetFieldSpec
1678   | ObjectFieldSpec
1679   | ObjectSetFieldSpec
1680   ;
1681
1682 TypeFieldSpec
1683   : TYPEFIELDREFERENCE TypeOptionalitySpec
1684     { }
1685   ;
1686
1687 TypeOptionalitySpec
1688   : OPTIONAL_t
1689   | DEFAULT Type
1690   | /* empty */
1691   ;
1692
1693 FixedTypeValueFieldSpec
1694   : VALUEFIELDREFERENCE Type Unique ValueOptionalitySpec
1695     { }
1696   ;
1697
1698 Unique
1699   : UNIQUE
1700   | /* empty */
1701   ;
1702
1703 ValueOptionalitySpec
1704   : OPTIONAL_t
1705   | DEFAULT Value
1706   | /* empty */
1707   ;
1708
1709 VariableTypeValueFieldSpec
1710   : VALUEFIELDREFERENCE FieldName ValueOptionalitySpec
1711     { }
1712   ;
1713
1714 FixedTypeValueSetFieldSpec
1715   : VALUESETFIELDREFERENCE Type ValueSetOptionalitySpec
1716     { }
1717   ;
1718
1719 ValueSetOptionalitySpec
1720   : OPTIONAL_t
1721   | DEFAULT ValueSet
1722   | /* empty */
1723   ;
1724
1725 VariableTypeValueSetFieldSpec
1726   : VALUESETFIELDREFERENCE FieldName ValueSetOptionalitySpec
1727     { }
1728   ;
1729
1730 ObjectFieldSpec
1731   : OBJECTFIELDREFERENCE DefinedObjectClass ObjectOptionalitySpec
1732     { }
1733   ;
1734
1735 ObjectOptionalitySpec
1736   : OPTIONAL_t
1737   | DEFAULT Object
1738   | /* empty */
1739   ;
1740
1741 ObjectSetFieldSpec
1742   : OBJECTSETFIELDREFERENCE DefinedObjectClass ObjectSetOptionalitySpec
1743     { }
1744   ;
1745
1746 ObjectSetOptionalitySpec
1747   : OPTIONAL_t
1748   | DEFAULT ObjectSet
1749   | /* empty */
1750   ;
1751
1752 WithSyntaxSpec
1753   : WITH SYNTAX SyntaxList
1754   | /* empty */
1755   ;
1756
1757 SyntaxList
1758   : '{' TokenOrGroupSpecs '}'
1759   | '{' '}'
1760   ;
1761
1762 TokenOrGroupSpecs
1763   : TokenOrGroupSpecs TokenOrGroupSpec
1764   | TokenOrGroupSpec
1765   ;
1766
1767 TokenOrGroupSpec
1768   : RequiredToken
1769   | OptionalGroup
1770   ;
1771
1772 OptionalGroup
1773   : '[' TokenOrGroupSpecs ']'
1774   ;
1775
1776 RequiredToken
1777   : Literal
1778   | PrimitiveFieldName
1779     { }
1780   ;
1781
1782 Literal
1783   : BIT
1784   | BOOLEAN_t
1785   | CHARACTER
1786   | CHOICE
1787   | EMBEDDED
1788   | END
1789   | ENUMERATED
1790   | EXTERNAL
1791   | FALSE_t
1792   | INSTANCE
1793   | INTEGER
1794     { }
1795   | INTERSECTION
1796   | MINUS_INFINITY
1797   | NULL_TYPE
1798   | OBJECT
1799   | OCTET
1800   | PLUS_INFINITY
1801   | REAL
1802   | SEQUENCE
1803   | SET
1804   | TRUE_t
1805   | UNION
1806   | ','
1807   ;
1808
1809
1810 DefinedObject
1811   : ExternalObjectReference
1812   | OBJECTREFERENCE
1813     { }
1814   ;
1815
1816 ExternalObjectReference
1817   : MODULEREFERENCE '.' OBJECTREFERENCE
1818     { }
1819   ;
1820
1821
1822 ParameterizedObjectClass
1823   : DefinedObjectClass ActualParameterList
1824     { }
1825   ;
1826
1827
1828 DefinedObjectSet
1829   : ExternalObjectSetReference
1830     { }
1831   | OBJECTSETREFERENCE
1832     { }
1833   ;
1834
1835 ExternalObjectSetReference
1836   : MODULEREFERENCE '.' OBJECTSETREFERENCE
1837     { }
1838   ;
1839
1840
1841 ParameterizedObjectSet
1842   : DefinedObjectSet ActualParameterList
1843   ;
1844
1845
1846 FieldName
1847   : FieldName '.' PrimitiveFieldName
1848       {
1849         $$ = ConcatNames($1, '.', $3);
1850       }
1851   | PrimitiveFieldName
1852   ;
1853
1854
1855 PrimitiveFieldName
1856   : TYPEFIELDREFERENCE
1857   | VALUEFIELDREFERENCE
1858   | VALUESETFIELDREFERENCE
1859   | OBJECTFIELDREFERENCE
1860   | OBJECTSETFIELDREFERENCE
1861   ;
1862
1863
1864 Object
1865   : DefinedObject
1866     { }
1867 /*!!!
1868   | ObjectDefn
1869     { }
1870 */
1871   | ObjectFromObject
1872     { }
1873   | ParameterizedObject
1874     { }
1875   ;
1876
1877
1878 /*!!!!
1879 ObjectDefn
1880   : DefaultSyntax
1881   | DefinedSyntax
1882   ;
1883
1884 DefaultSyntax
1885   : '{' FieldSettings '}
1886   : '{' '}
1887   ;
1888
1889 FieldSettings
1890   : FieldSettings ',' FieldSetting
1891   | FieldSetting
1892   ;
1893
1894 FieldSetting
1895   : PrimitiveFieldName Setting
1896   ;
1897
1898 DefinedSyntax
1899   : '{' DefinedSyntaxTokens '}'
1900   '
1901
1902 DefinedSyntaxTokens
1903   : DefinedSyntaxTokens DefinedSyntaxToken
1904   | /* empty *//*
1905   ;
1906
1907 DefinedSyntaxToken
1908   : Literal
1909   | Setting
1910   ;
1911
1912 Setting
1913   : Type
1914   | Value
1915   | ValueSet
1916   | Object
1917   | ObjectSet
1918   ;
1919 */
1920
1921
1922 ObjectSet
1923   : '{' ElementSetSpec '}'
1924     { }
1925   ;
1926
1927
1928 ObjectFromObject
1929   : ReferencedObjects '.' FieldName
1930   ;
1931
1932
1933 ObjectSetElements
1934   : Object
1935     { }
1936   | DefinedObjectSet
1937     { }
1938 /*!!!
1939   | ObjectSetFromObjects
1940 */
1941   | ParameterizedObjectSet
1942     { }
1943   ;
1944
1945 /*!!!
1946 ObjectSetFromObjects
1947   : ReferencedObjects '.' FieldName
1948   ;
1949 */
1950
1951
1952
1953 /********/
1954
1955 ParameterizedAssignment
1956   : ParameterizedTypeAssignment
1957   | ParameterizedValueAssignment
1958   | ParameterizedValueSetTypeAssignment
1959   | ParameterizedObjectClassAssignment
1960   | ParameterizedObjectAssignment
1961   | ParameterizedObjectSetAssignment
1962   ;
1963
1964 ParameterizedTypeAssignment
1965   : TYPEREFERENCE ParameterList
1966       {
1967         DummyParameters = $2;
1968       }
1969     ASSIGNMENT Type
1970       {
1971         DummyParameters = NULL;
1972         $5->SetName($1);
1973         $5->SetParameters($2);
1974         Module->AddType($5);
1975       }
1976   ;
1977
1978 ParameterizedValueAssignment
1979   : IDENTIFIER ParameterList Type ASSIGNMENT Value
1980     { }
1981   ;
1982
1983 ParameterizedValueSetTypeAssignment
1984   : TYPEREFERENCE ParameterList Type ASSIGNMENT ValueSet
1985     { }
1986   ;
1987
1988 ParameterizedObjectClassAssignment
1989   : OBJECTCLASSREFERENCE ParameterList ASSIGNMENT ObjectClass
1990     { }
1991   ;
1992
1993 ParameterizedObjectAssignment
1994   : OBJECTREFERENCE ParameterList DefinedObjectClass ASSIGNMENT Object
1995     { }
1996   ;
1997
1998 ParameterizedObjectSetAssignment
1999   : OBJECTSETREFERENCE ParameterList DefinedObjectClass ASSIGNMENT ObjectSet
2000     { }
2001   ;
2002
2003 ParameterList
2004   : '{' Parameters '}'
2005       {
2006         $$ = $2;
2007       }
2008   ;
2009
2010 Parameters
2011   : Parameters ',' Parameter
2012       {
2013         $$ = $1;
2014         $$->Append($3);
2015       }
2016   | Parameter
2017       {
2018         $$ = new PStringList;
2019         $$->Append($1);
2020       }
2021   ;
2022
2023 Parameter
2024   : Governor ':' Reference
2025       {
2026         $$ = $3;
2027       }
2028   | Reference
2029   ;
2030
2031 Governor
2032   : Type
2033     { }
2034   | DefinedObjectClass
2035     { }
2036   ;
2037
2038
2039 ParameterizedType
2040   : SimpleDefinedType ActualParameterList
2041       {
2042         $$ = new ParameterizedType($1, $2);
2043       }
2044   ;
2045
2046 SimpleDefinedType
2047   : ExternalTypeReference
2048   | TYPEREFERENCE
2049   ;
2050
2051
2052 ActualParameterList
2053   : '{' ActualParameters '}'
2054       {
2055         $$ = $2;
2056       }
2057   ;
2058
2059 ActualParameters
2060   : ActualParameters ',' ActualParameter
2061       {
2062         $1->Append($3);
2063         $$ = $1;
2064       }
2065   | ActualParameter
2066       {
2067         $$ = new TypesList;
2068         $$->Append($1);
2069       }
2070   ;
2071
2072 ActualParameter
2073   : Type
2074   | Value
2075     { }
2076   | ValueSet
2077     { }
2078   | DefinedObjectClass
2079     { }
2080 /*!!!
2081   | Object
2082     { }
2083   | ObjectSet
2084 */
2085   ;
2086
2087
2088
2089 /********/
2090
2091 ValueAssignment
2092   : IDENTIFIER Type
2093       {
2094         IdentifierTokenContext = $2->GetIdentifierTokenContext();
2095         BraceTokenContext = $2->GetBraceTokenContext();
2096         NullTokenContext = NULL_VALUE;
2097       }
2098     ASSIGNMENT Value
2099       {
2100         $5->SetValueName($1);
2101         Module->AddValue($5);
2102         IdentifierTokenContext = IDENTIFIER;
2103         BraceTokenContext = '{';
2104         NullTokenContext = NULL_TYPE;
2105       }
2106   ;
2107
2108
2109 Value
2110   : BuiltinValue
2111   | ReferencedValue
2112   ;
2113
2114
2115 BuiltinValue
2116   : BitStringValue
2117   | BooleanValue
2118   | CharacterStringValue
2119   | ChoiceValue
2120 /*| EmbeddedPDVValue  synonym to SequenceValue */
2121 /*| EnumeratedValue   synonym to IDENTIFIER    */
2122 /*| ExternalValue     synonym to SequenceValue */
2123 /*| InstanceOfValue   synonym to Value */
2124   | SignedNumber      /* IntegerValue */
2125       {
2126         $$ = new IntegerValue($1);
2127       }
2128   | NullValue
2129 /*!!!
2130   | ObjectClassFieldValue
2131 */
2132   | ObjectIdentifierValue
2133   | OctetStringValue
2134   | RealValue
2135   | SequenceValue
2136 /*!!!!
2137   | SequenceOfValue
2138 */
2139 /*| SetValue          synonym to SequenceValue */
2140 /*| SetOfValue        synonym to SequenceOfValue */
2141 /*| TaggedValue       synonym to Value */
2142   ;
2143
2144
2145 DefinedValue
2146   : ExternalValueReference
2147       {
2148         $$ = new DefinedValue($1);
2149       }
2150   | IDENTIFIER
2151       {
2152         $$ = new DefinedValue($1);
2153       }
2154   | ParameterizedValue
2155   ;
2156
2157
2158 ExternalValueReference
2159   : MODULEREFERENCE '.' IDENTIFIER
2160       {
2161         *$1 += *$3;
2162         delete $3;
2163       }
2164   ;
2165
2166
2167 ObjectIdentifierValue
2168   : OID_BRACE
2169       {
2170         IdentifierTokenContext = OID_IDENTIFIER;
2171       }
2172     ObjIdComponentList '}'
2173       {
2174         $$ = new ObjectIdentifierValue($3);
2175         IdentifierTokenContext = IDENTIFIER;
2176       }
2177 /*!!!
2178   | '{' DefinedValue_OID ObjIdComponentList '}'
2179       {
2180         $$ = new ObjectIdentifierValue($2);
2181       }
2182 */
2183   ;
2184
2185
2186 ObjIdComponentList
2187   : ObjIdComponent
2188       {
2189         $$ = new PStringList;
2190         $$->Append($1);
2191       }
2192   | ObjIdComponent ObjIdComponentList
2193       {
2194         $2->InsertAt(0, $1);
2195         $$ = $2;
2196       }
2197   ;
2198
2199 ObjIdComponent
2200   : OID_IDENTIFIER
2201   | INTEGER
2202       {
2203         $$ = new PString(PString::Unsigned, (int)$1);
2204       }
2205   | OID_IDENTIFIER '(' NumberForm ')'
2206       {
2207         delete $1;
2208         $$ = $3;
2209       }
2210   ;
2211
2212 NumberForm
2213   : INTEGER
2214       {
2215         $$ = new PString(PString::Unsigned, (int)$1);
2216       }
2217   | ExternalValueReference
2218   | OID_IDENTIFIER
2219   ;
2220
2221
2222 OctetStringValue
2223   : OS_BSTRING
2224       {
2225         $$ = new OctetStringValue($1);
2226       }
2227   | OS_HSTRING
2228       {
2229         $$ = new OctetStringValue($1);
2230       }
2231   ;
2232
2233 BitStringValue
2234   : BS_BSTRING
2235       {
2236         $$ = new BitStringValue($1);
2237       }
2238   | BS_HSTRING
2239       {
2240         $$ = new BitStringValue($1);
2241       }
2242   | BITSTRING_BRACE BitIdentifierList '}'
2243       {
2244         $$ = new BitStringValue($2);
2245       }
2246   | BITSTRING_BRACE  '}'
2247       {
2248         $$ = new BitStringValue;
2249       }
2250   ;
2251
2252
2253 BitIdentifierList
2254   : BIT_IDENTIFIER
2255       {
2256         $$ = new PStringList;
2257       }
2258   | BitIdentifierList ',' BIT_IDENTIFIER
2259       {
2260         // Look up $3
2261         $1->SetAt($1->GetSize(), 0);
2262       }
2263   ;
2264
2265
2266 BooleanValue
2267   : TRUE_t
2268       {
2269         $$ = new BooleanValue(TRUE);
2270       }
2271   | FALSE_t
2272       {
2273         $$ = new BooleanValue(FALSE);
2274       }
2275   ;
2276
2277
2278 CharacterStringValue
2279   : RestrictedCharacterStringValue
2280 /*!!!
2281   | UnrestrictedCharacterStringValue
2282 */
2283   ;
2284
2285 RestrictedCharacterStringValue
2286   : CSTRING
2287       {
2288         $$ = new CharacterStringValue($1);
2289       }
2290   | CharacterStringList
2291   | Quadruple
2292   | Tuple
2293   ;
2294
2295 CharacterStringList
2296   : STRING_BRACE CharSyms '}'
2297       {
2298         $$ = new CharacterStringValue($2);
2299       }
2300   ;
2301
2302 CharSyms
2303   : CharsDefn
2304       {
2305         $$ = new PStringList;
2306         $$->Append($1);
2307       }
2308   | CharSyms ',' CharsDefn
2309       {
2310         $1->Append($3);
2311       }
2312   ;
2313
2314 CharsDefn
2315   : CSTRING
2316   | DefinedValue
2317       {
2318         PError << StdError(Warning) << "DefinedValue in string unsupported" << endl;
2319       }
2320   ;
2321
2322 Quadruple
2323   :  STRING_BRACE  INTEGER  ','  INTEGER  ','  INTEGER  ','  INTEGER '}'
2324       {
2325         if ($2 != 0 || $4 != 0 || $6 > 255 || $8 > 255)
2326           PError << StdError(Warning) << "Illegal value in Character Quadruple" << endl;
2327         $$ = new CharacterValue((BYTE)$2, (BYTE)$4, (BYTE)$6, (BYTE)$8);
2328       }
2329   ;
2330
2331 Tuple
2332   :  STRING_BRACE INTEGER ',' INTEGER '}'
2333       {
2334         if ($2 > 255 || $4 > 255)
2335           PError << StdError(Warning) << "Illegal value in Character Tuple" << endl;
2336         $$ = new CharacterValue((BYTE)$2, (BYTE)$4);
2337       }
2338   ;
2339
2340
2341 ChoiceValue
2342   : IDENTIFIER ':' Value
2343       {
2344         $3->SetValueName($1);
2345         $$ = $3;
2346       }
2347   ;
2348
2349
2350 NullValue
2351   : NULL_VALUE
2352       {
2353         $$ = new NullValue;
2354       }
2355   ;
2356
2357
2358 RealValue
2359   : NumericRealValue
2360   | SpecialRealValue
2361   ;
2362
2363 NumericRealValue
2364   :  '0'
2365       {
2366         $$ = new RealValue(0);
2367       }
2368 /*!!!
2369   | SequenceValue
2370 */
2371   ;
2372
2373 SpecialRealValue
2374   : PLUS_INFINITY
2375       {
2376         $$ = new RealValue(0);
2377       }
2378   | MINUS_INFINITY
2379       {
2380         $$ = new RealValue(0);
2381       }
2382   ;
2383
2384
2385 SequenceValue
2386   : '{' ComponentValueList '}'
2387       {
2388         $$ = new SequenceValue($2);
2389       }
2390   | '{'  '}'
2391       {
2392         $$ = new SequenceValue;
2393       }
2394   ;
2395
2396 ComponentValueList
2397   : NamedValue
2398       {
2399         $$ = new ValuesList;
2400         $$->Append($1);
2401       }
2402   | ComponentValueList ',' NamedValue
2403       {
2404         $1->Append($3);
2405       }
2406   ;
2407
2408 NamedValue
2409   : IDENTIFIER Value
2410       {
2411         $2->SetValueName($1);
2412         $$ = $2;
2413       }
2414   ;
2415
2416
2417 /*!!!!
2418 SequenceOfValue
2419   : '{' ValueList '}'
2420       {
2421         $$ = NULL;
2422       }
2423   | '{'  '}'
2424       {
2425         $$ = NULL;
2426       }
2427   ;
2428
2429 ValueList
2430   : Value
2431       { }
2432   | ValueList ',' Value
2433       { }
2434   ;
2435 */
2436
2437
2438 /*!!!
2439 ObjectClassFieldValue
2440   : OpenTypeFieldVal
2441   | Value
2442   ;
2443
2444 OpenTypeFieldVal
2445   : Type ':' Value
2446   ;
2447 */
2448
2449
2450 ReferencedValue
2451   : DefinedValue
2452 /*!!!!
2453   | ValueFromObject
2454 */
2455   ;
2456
2457 /*!!!!
2458 ValueFromObject
2459   : ReferencedObjects '.' FieldName
2460     { }
2461   ;
2462 */
2463
2464
2465 ParameterizedValue
2466   : SimpleDefinedValue ActualParameterList
2467     { }
2468   ;
2469
2470 SimpleDefinedValue
2471   : ExternalValueReference
2472   | IDENTIFIER
2473   ;
2474
2475
2476
2477 /********/
2478
2479 ValueSet
2480   : '{' ElementSetSpecs '}'
2481   ;
2482
2483
2484 /********/
2485
2486 MacroDefinition
2487   : TYPEREFERENCE MACRO ASSIGNMENT MacroSubstance
2488       {
2489         PError << StdError(Warning) << "MACRO unsupported" << endl;
2490       }
2491   ;
2492
2493 MacroSubstance
2494   : BEGIN_t
2495       {
2496         InMacroContext = TRUE;
2497       }
2498     MacroBody END
2499       {
2500         InMacroContext = FALSE;
2501       }
2502   | TYPEREFERENCE
2503       {}
2504   | TYPEREFERENCE '.' TYPEREFERENCE
2505       {}
2506   ;
2507
2508 MacroBody
2509   : TypeProduction ValueProduction /*SupportingProductions*/
2510   ;
2511
2512 TypeProduction
2513   : TYPE_t NOTATION ASSIGNMENT MacroAlternativeList
2514   ;
2515
2516 ValueProduction
2517   : VALUE NOTATION ASSIGNMENT MacroAlternativeList
2518   ;
2519
2520
2521 /*
2522 SupportingProductions
2523   : ProductionList
2524   | /* empty *//*
2525   ;
2526
2527 ProductionList
2528   : Production
2529   | ProductionList Production
2530   ;
2531
2532 Production
2533   : TYPEREFERENCE ASSIGNMENT MacroAlternativeList
2534
2535   ;
2536 */
2537
2538 MacroAlternativeList
2539   : MacroAlternative
2540   | MacroAlternative '|' MacroAlternativeList
2541   ;
2542
2543 MacroAlternative
2544   : SymbolElement
2545   | SymbolElement MacroAlternative
2546   ;
2547
2548 SymbolElement
2549   : SymbolDefn
2550   | EmbeddedDefinitions
2551   ;
2552
2553 SymbolDefn
2554   : CSTRING
2555       {}
2556   | TYPEREFERENCE
2557       {}
2558   | TYPEREFERENCE ASSIGNMENT
2559       {}
2560   | string_t
2561   | identifier_t
2562   | number_t
2563   | empty_t
2564   | type_t
2565   | type_t '(' TYPE_t TYPEREFERENCE ')'
2566   | value_t '(' Type ')'
2567   | value_t '(' IDENTIFIER Type ')'
2568   | value_t '(' VALUE Type ')'
2569   ;
2570
2571 EmbeddedDefinitions
2572   : '<' EmbeddedDefinitionList '>'
2573   ;
2574
2575 EmbeddedDefinitionList
2576   : EmbeddedDefinition
2577   | EmbeddedDefinitionList EmbeddedDefinition
2578   ;
2579
2580 EmbeddedDefinition
2581   : LocalTypeAssignment
2582   | LocalValueAssignment
2583   ;
2584
2585 LocalTypeAssignment
2586   : TYPEREFERENCE ASSIGNMENT Type
2587       {}
2588   ;
2589
2590 LocalValueAssignment
2591   : IDENTIFIER Type ASSIGNMENT Value
2592       {}
2593   ;
2594
2595
2596 /********/
2597
2598 ObjectTypeDefinition
2599   : IDENTIFIER OBJECT_TYPE
2600       {
2601         InMIBContext = TRUE;
2602       }
2603     SYNTAX Type
2604     ACCESS ObjectTypeAccess
2605     STATUS ObjectTypeStatus
2606     MibDescrPart
2607     MibReferPart
2608     MibIndexPart
2609     MibDefValPart
2610       {
2611         IdentifierTokenContext = OID_IDENTIFIER;
2612       }
2613     ASSIGNMENT Value
2614       {
2615         Module->AddMIB(new MibObject($1, $5, (MibObject::Access)$7, (MibObject::Status)$9, $10, $11, $12, $13, $16));
2616         InMIBContext = FALSE;
2617         IdentifierTokenContext = IDENTIFIER;
2618       }
2619   ;
2620
2621 ObjectTypeAccess
2622   : read_only_t
2623       {
2624         $$ = MibObject::read_only;
2625       }
2626   | read_write_t
2627       {
2628         $$ = MibObject::read_write;
2629       }
2630   | write_only_t
2631       {
2632         $$ = MibObject::write_only;
2633       }
2634   | not_accessible_t
2635       {
2636         $$ = MibObject::not_accessible;
2637       }
2638   ;
2639
2640 ObjectTypeStatus
2641   : mandatory_t
2642       {
2643         $$ = MibObject::mandatory;
2644       }
2645   | optional_t
2646       {
2647         $$ = MibObject::optional;
2648       }
2649   | obsolete_t
2650       {
2651         $$ = MibObject::obsolete;
2652       }
2653   | deprecated_t
2654       {
2655         $$ = MibObject::deprecated;
2656       }
2657   ;
2658
2659 MibDescrPart
2660   : DESCRIPTION_t CSTRING
2661       {
2662         $$ = $2;
2663       }
2664   | /* empty */
2665       {
2666         $$ = NULL;
2667       }
2668   ;
2669
2670 MibReferPart
2671   : REFERENCE_t CSTRING
2672       {
2673         $$ = $2;
2674       }
2675   | /* empty */
2676       {
2677         $$ = NULL;
2678       }
2679   ;
2680
2681 MibIndexPart
2682   : INDEX_t '{' MibIndexTypes '}'
2683       {
2684         $$ = $3;
2685       }
2686   | /* empty */
2687       {
2688         $$ = NULL;
2689       }
2690   ;
2691
2692 MibIndexTypes
2693   : MibIndexType
2694       {
2695         $$ = new PStringList;
2696         $$->Append($1);
2697       }
2698   | MibIndexTypes ',' MibIndexType
2699       {
2700         $1->Append($3);
2701       }
2702   ;
2703
2704 MibIndexType
2705   : IDENTIFIER
2706   | TYPEREFERENCE
2707   ;
2708
2709 MibDefValPart
2710   : DEFVAL_t '{' Value '}'
2711       {
2712         $$ = $3;
2713       }
2714   | /* empty */
2715       {
2716         $$ = NULL;
2717       }
2718   ;
2719
2720 TrapTypeDefinition
2721   : IDENTIFIER TRAP_TYPE
2722       {
2723         InMIBContext = TRUE;
2724         IdentifierTokenContext = OID_IDENTIFIER;
2725       }
2726     ENTERPRISE Value
2727     MibVarPart
2728     MibDescrPart
2729     MibReferPart
2730     ASSIGNMENT Value
2731       {
2732         Module->AddMIB(new MibTrap($1, $5, $6, $7, $8, $10));
2733         IdentifierTokenContext = IDENTIFIER;
2734         InMIBContext = FALSE;
2735       }
2736   ;
2737
2738 MibVarPart
2739   : VARIABLES '{' MibVarTypes '}'
2740       {
2741         $$ = $3;
2742       }
2743   | /* empty */
2744       {
2745         $$ = NULL;
2746       }
2747   ;
2748
2749 MibVarTypes
2750   : Value
2751       {
2752         $$ = new ValuesList;
2753         $$->Append($1);
2754       }
2755   | MibVarTypes ',' Value
2756       {
2757         $1->Append($3);
2758       }
2759   ;
2760
2761
2762
2763 /********/
2764
2765 /*!!! Not actually referenced by any other part of grammar
2766 AbsoluteReference
2767   : '@' GlobalModuleReference '.' ItemSpec
2768   ;
2769
2770 ItemSpec
2771   : TYPEREFERENCE
2772   |  ItemId '.' ComponentId
2773   ;
2774
2775 ItemId
2776   : ItemSpec
2777   ;
2778
2779 ComponentId
2780   : IDENTIFIER
2781   | INTEGER
2782   | '*'
2783   ;
2784 */
2785
2786
2787 Reference
2788   : TYPEREFERENCE
2789   | IDENTIFIER
2790   | OBJECTCLASSREFERENCE
2791   | OBJECTREFERENCE
2792   | OBJECTSETREFERENCE
2793   ;
2794
2795 ParameterizedReference
2796   : Reference '{' '}'
2797       {
2798         $$ = new ImportedType($1, TRUE);
2799       }
2800   ;
2801
2802
2803 NamedNumberList
2804   : NamedNumber
2805       {
2806         $$ = new NamedNumberList;
2807         $$->Append($1);
2808       }
2809   | NamedNumberList ',' NamedNumber
2810       {
2811         $1->Append($3);
2812       }
2813   ;
2814
2815 NamedNumber
2816   : IDENTIFIER '(' SignedNumber ')'
2817       {
2818         $$ = new NamedNumber($1, (int)$3);
2819       }
2820   | IDENTIFIER '(' DefinedValue ')'
2821       {
2822         $$ = new NamedNumber($1, ((DefinedValue*)$3)->GetReference());
2823         delete $3;
2824       }
2825   ;
2826
2827
2828 SignedNumber
2829   :  INTEGER
2830   | '-' INTEGER
2831       {
2832         $$ = -$2;
2833       }
2834   ;
2835
2836
2837 /** End of File ****/