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