compiler2/ttcn3/compiler.y

   1 /******************************************************************************
   2  * Copyright (c) 2000-2014 Ericsson Telecom AB
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  ******************************************************************************/
   8 /* Syntax check parser and compiler for TTCN-3 */
   9
  10 /* BNF compliance: v3.2.1 with extensions */
  11
  12 %{
  13
  14 /* C declarations */
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <errno.h>
  20
  21 #include "../../common/dbgnew.hh"
  22 #include "../../common/memory.h"
  23
  24 #include "../datatypes.h"
  25 #include "Attributes.hh"
  26 #include "../main.hh"
  27 #include "compiler.h"
  28
  29 #include "../Identifier.hh"
  30 #include "Templatestuff.hh"
  31 #include "AST_ttcn3.hh"
  32 #include "../Type.hh"
  33 #include "../CompType.hh"
  34 #include "../CompField.hh"
  35 #include "../EnumItem.hh"
  36 #include "../SigParam.hh"
  37
  38 #include "../subtype.hh"
  39 #include "../Value.hh"
  40 #include "../Valuestuff.hh"
  41 #include "../ustring.hh"
  42 #include "Ttcnstuff.hh"
  43 #include "TtcnTemplate.hh"
  44 #include "Templatestuff.hh"
  45 #include "ArrayDimensions.hh"
  46 #include "PatternString.hh"
  47 #include "Statement.hh"
  48
  49 using namespace Ttcn;
  50 using namespace Common;
  51
  52 const char *infile = NULL;
  53
  54 static Ttcn::Module *act_ttcn3_module = NULL;
  55 static Ttcn::ErroneousAttributeSpec *act_ttcn3_erroneous_attr_spec = NULL;
  56 bool is_erroneous_parsed = false;
  57 static void ttcn3_error(const char *str);
  58 static Group* act_group = NULL;
  59 extern string anytype_field(const string& type_name);
  60 static bool anytype_access = false;
  61
  62 #ifndef NDEBUG
  63
  64 union YYSTYPE;
  65 static void yyprint(FILE *file, int type, const YYSTYPE& value);
  66 #define YYPRINT(f,t,v) yyprint(f,t,v)
  67
  68 #endif
  69
  70 extern Modules *modules;
  71
  72 extern FILE *ttcn3_in;
  73 extern char *ttcn3_text;
  74 extern int ttcn3_lex();
  75 extern void init_ttcn3_lex();
  76 extern void free_ttcn3_lex();
  77 extern void set_md5_checksum(Ttcn::Module *m);
  78
  79 extern void init_erroneous_lex(const char* p_infile, int p_line, int p_column);
  80 struct yy_buffer_state;
  81 extern int ttcn3_lex_destroy(void);
  82 extern yy_buffer_state *ttcn3__scan_string(const char *yy_str);
  83 extern void free_dot_flag_stuff();
  84
  85 extern string *parse_charstring_value(const char *str, const Location& loc);
  86 extern PatternString* parse_pattern(const char *str, const Location& loc);
  87
  88 static const string anyname("anytype");
  89
  90 /* Various C macros */
  91
  92 #define YYERROR_VERBOSE
  93
  94
  95 %}
  96
  97 /* Bison declarations */
  98
  99 /*********************************************************************
 100  * The union-type
 101  *********************************************************************/
 102
 103 %union {
 104   /* NOTE: the union is written to compiler.tab.hh, which is #included
 105    * into compiler.l; therefore all types used here must be declared
 106    * in compiler.l (forward declared or #included) */
 107   bool bool_val; /* boolean value */
 108   char *str; /* simple string value */
 109   unsigned char uchar_val;
 110
 111   int_val_t *int_val; /* integer value */
 112   Real float_val; /* float value */
 113   Identifier *id;
 114   string *string_val;
 115   ustring *ustring_val;
 116
 117   Type::typetype_t typetype;
 118   PortTypeBody::PortOperationMode_t portoperationmode;
 119   Value::operationtype_t operationtype;
 120   Value::macrotype_t macrotype;
 121   SingleWithAttrib::attribtype_t attribtype;
 122   ImpMod::imptype_t imptype;
 123
 124   AltGuard *altguard;
 125   AltGuards *altguards;
 126   ArrayDimension *arraydimension;
 127   AttributeSpec *attributespec;
 128   CompField *compfield;
 129   CompFieldMap *compfieldmap;
 130   Def_Type *deftype;
 131   Def_Timer *deftimer;
 132   Definition *definition;
 133   Definitions *defs;
 134   EnumItem *enumitem;
 135   EnumItems *enumitems;
 136   FieldOrArrayRef *fieldorarrayref;
 137   FormalPar *formalpar;
 138   FormalParList *formalparlist;
 139   Group *group;
 140   FriendMod *friendMod;
 141   IfClause *ifclause;
 142   IfClauses *ifclauses;
 143   ImpMod *impmod;
 144   LengthRestriction *lenrestr;
 145   LogArgument *logarg;
 146   LogArguments *logargs;
 147   NamedTemplate *namedtempl;
 148   NamedTemplates *namedtempls;
 149   NamedValue *namedvalue;
 150   NamedValues *namedvalues;
 151   IndexedTemplate *indexedtempl;
 152   IndexedTemplates *indexedtempls;
 153   IndexedValue *indexedvalue;
 154   MultiWithAttrib *multiwithattrib;
 155   OID_comp *oidcomp;
 156   ParamAssignment *parass;
 157   ParamAssignments *parasss;
 158   ParamRedirect *parredir;
 159   ParsedActualParameters *parsedpar;
 160   PatternString *patstr;
 161   Qualifier *qualifier;
 162   Qualifiers *qualifiers;
 163   SelectCase *selectcase;
 164   SelectCases *selectcases;
 165   SignatureExceptions *signexc;
 166   SignatureParam *signparam;
 167   SignatureParamList *signparamlist;
 168   SingleWithAttrib *singlewithattrib;
 169   Statement *stmt;
 170   StatementBlock *statementblock;
 171   SubTypeParse *subtypeparse;
 172   Template *templ;
 173   TemplateInstance *templinst;
 174   TemplateInstances *templinsts;
 175   Templates *templs;
 176   Ttcn::Assignment *ass;
 177   Ttcn::Ref_base *refbase;
 178   Ttcn::Ref_pard *refpard;
 179   Ttcn::Reference *reference;
 180   ValueRange *valuerange;
 181   Type *type;
 182   Types *types;
 183   Value *value;
 184   Values *values;
 185   VariableEntries *variableentries;
 186   VariableEntry *variableentry;
 187   vector<SubTypeParse> *subtypeparses;
 188   CompTypeRefList *comprefs;
 189   ComponentTypeBody *compbody;
 190   template_restriction_t template_restriction;
 191
 192   struct {
 193     bool is_raw;
 194     ErroneousAttributeSpec::indicator_t indicator;
 195   } erroneous_indicator;
 196
 197   struct arraydimension_list_t {
 198     size_t nElements;
 199     ArrayDimension **elements;
 200   } arraydimension_list;
 201
 202   struct {
 203     size_t nElements;
 204     FieldOrArrayRef **elements;
 205   } fieldorarrayref_list;
 206
 207   struct {
 208     size_t nElements;
 209     Ttcn::Definition **elements;
 210   } def_list;
 211
 212   struct {
 213     size_t nElements;
 214     Ttcn::FriendMod **elements;
 215   } friend_list;
 216
 217   struct {
 218     size_t nElements;
 219     Statement **elements;
 220   } stmt_list;
 221
 222
 223   struct {
 224     Value *lower;
 225     bool lower_exclusive;
 226     Value *upper;
 227     bool upper_exclusive;
 228   } rangedef;
 229
 230   struct {
 231     Type *type;
 232     bool returns_template;
 233     template_restriction_t template_restriction;
 234   } returntype;
 235
 236   struct {
 237     Type *type;
 238     bool no_block_kw;
 239   } returntypeornoblock;
 240
 241   struct {
 242     Identifier *id;
 243     CompFieldMap* cfm;
 244   } structdefbody;
 245
 246   struct {
 247     Type *type;
 248     Identifier *id;
 249   } structofdefbody;
 250
 251   struct {
 252     Ttcn::Types *in_list, *out_list, *inout_list;
 253     bool in_all, out_all, inout_all;
 254   } portdefbody;
 255
 256   struct {
 257     Ttcn::Reference *ref;
 258     Identifier *id;
 259   } ischosenarg;
 260
 261   struct {
 262     bool is_ifpresent;
 263     LengthRestriction *len_restr;
 264   } extramatchingattrs;
 265
 266   struct {
 267     Identifier *name;
 268     Type *type;
 269     FormalParList *fp_list;
 270   } basetemplate;
 271
 272   struct {
 273     Identifier *modid;
 274     Identifier *id;
 275   } templateref;
 276
 277   struct {
 278     Ttcn::Ref_pard *ref_pard;
 279     Value *derefered_value;
 280     ParsedActualParameters *ap_list;
 281     Value *value;
 282   } testcaseinst;
 283
 284   struct {
 285     Ttcn::Ref_pard *ref_pard;
 286     Value *derefered_value;
 287     TemplateInstances *ap_list;
 288   } activateop;
 289
 290   struct {
 291     TemplateInstance *templ_inst;
 292     Value *val;
 293   } portsendop;
 294
 295   struct {
 296     Value *calltimerval; // if NULL: see nowait
 297     bool nowait;
 298   } calltimerval;
 299
 300   struct {
 301     TemplateInstance *templ_inst;
 302     Value *calltimerval; // if NULL: see nowait
 303     bool nowait;
 304     Value *val; // not used in callparams
 305   } portcallop;
 306
 307   struct {
 308     TemplateInstance *templ_inst;
 309     Value *replyval;
 310     Value *toclause;
 311   } portreplyop;
 312
 313   struct {
 314     Ttcn::Reference *signature;
 315     TemplateInstance *templ_inst;
 316     Value *toclause;
 317   } portraiseop;
 318
 319   struct {
 320     Ttcn::Reference *redirectval;
 321     Ttcn::Reference *redirectsender;
 322   } portredirect;
 323
 324   struct {
 325     ParamRedirect *redirectparam;
 326     Ttcn::Reference *redirectsender;
 327   } portredirectwithparam;
 328
 329   struct {
 330     Ttcn::Reference *redirectval;
 331     ParamRedirect *redirectparam;
 332     Ttcn::Reference *redirectsender;
 333   } portredirectwithvalueandparam;
 334
 335   struct {
 336     TemplateInstance *templ_inst;
 337     TemplateInstance *valuematch;
 338   } getreplypar;
 339
 340   struct {
 341     TemplateInstance *templ_inst;
 342     TemplateInstance *fromclause;
 343     Ttcn::Reference *redirectval;
 344     Ttcn::Reference *redirectsender;
 345   } portreceiveop;
 346
 347   struct {
 348     TemplateInstance *templ_inst;
 349     TemplateInstance *fromclause;
 350     ParamRedirect *redirectparam;
 351     Ttcn::Reference *redirectsender;
 352   } portgetcallop;
 353
 354   struct {
 355     TemplateInstance *templ_inst;
 356     TemplateInstance *valuematch;
 357     TemplateInstance *fromclause;
 358     Ttcn::Reference *redirectval;
 359     ParamRedirect *redirectparam;
 360     Ttcn::Reference *redirectsender;
 361   } portgetreplyop;
 362
 363   struct {
 364     Ttcn::Reference *signature;
 365     TemplateInstance *templ_inst;
 366     bool timeout;
 367   } catchoppar;
 368
 369   struct {
 370     Ttcn::Reference *signature;
 371     TemplateInstance *templ_inst;
 372     bool timeout;
 373     TemplateInstance *fromclause;
 374     Ttcn::Reference *redirectval;
 375     Ttcn::Reference *redirectsender;
 376   } portcatchop;
 377
 378   struct {
 379     Statement::statementtype_t statementtype;
 380     Ttcn::Reference *signature;
 381     TemplateInstance *templ_inst;
 382     TemplateInstance *valuematch;
 383     bool timeout;
 384     TemplateInstance *fromclause;
 385     Ttcn::Reference *redirectval;
 386     ParamRedirect *redirectparam;
 387     Ttcn::Reference *redirectsender;
 388   } portcheckop;
 389
 390   struct {
 391     Value *compref;
 392     Ttcn::Reference *portref;
 393   } portref;
 394
 395   struct {
 396     Value *compref1;
 397     Ttcn::Reference *portref1;
 398     Value *compref2;
 399     Ttcn::Reference *portref2;
 400   } connspec;
 401
 402   struct {
 403     TemplateInstance *donematch;
 404     Ttcn::Reference *redirect;
 405   } donepar;
 406
 407   struct {
 408     bool is_ref;
 409     union {
 410       Ttcn::Reference *ref;
 411       Identifier *id;
 412     };
 413   } reforid;
 414
 415   struct {
 416     Definitions *defs;
 417     Ttcn::Assignment *ass;
 418   } initial;
 419
 420   struct {
 421     Ttcn::Reference *runsonref;
 422     Ttcn::Reference *systemref;
 423   } configspec;
 424
 425   struct {
 426     Value *name;
 427     Value *loc;
 428   } createpar;
 429
 430   struct {
 431     Value *value;
 432     ParsedActualParameters *ap_list;
 433   } applyop;
 434
 435
 436   struct extconstidentifier_t {
 437     Identifier *id;
 438     YYLTYPE yyloc;
 439   } extconstidentifier;
 440
 441   struct {
 442     size_t nElements;
 443     extconstidentifier_t *elements;
 444   } identifier_list;
 445
 446   struct singlevarinst_t {
 447     Identifier *id;
 448     arraydimension_list_t arrays;
 449     Value *initial_value;
 450     YYLTYPE yyloc;
 451   } singlevarinst;
 452
 453   struct singlevarinst_list_t {
 454     size_t nElements;
 455     struct singlevarinst_t *elements;
 456   } singlevarinst_list;
 457
 458   struct singletempvarinst_t {
 459     Identifier *id;
 460     arraydimension_list_t arrays;
 461     Template *initial_value;
 462     YYLTYPE yyloc;
 463   } singletempvarinst;
 464
 465   struct singletempvarinst_list_t {
 466     size_t nElements;
 467     singletempvarinst_t *elements;
 468   } singletempvarinst_list;
 469
 470   struct singlemodulepar_t {
 471     Identifier *id;
 472     Value *defval;
 473     YYLTYPE yyloc;
 474   } singlemodulepar;
 475
 476   struct singletemplatemodulepar_t {
 477     Identifier *id;
 478     Template *deftempl;
 479     YYLTYPE yyloc;
 480   } singletemplatemodulepar;
 481
 482   struct singlemodulepar_list_t {
 483     size_t nElements;
 484     singlemodulepar_t *elements;
 485   } singlemodulepar_list;
 486
 487   struct singletemplatemodulepar_list_t {
 488     size_t nElements;
 489     singletemplatemodulepar_t *elements;
 490   } singletemplatemodulepar_list;
 491
 492   struct portelement_t {
 493     Identifier *id;
 494     ArrayDimensions *dims;
 495     YYLTYPE yyloc;
 496   } portelement;
 497
 498   struct portelement_list_t {
 499     size_t nElements;
 500     portelement_t *elements;
 501   } portelement_list;
 502
 503   struct runs_on_compref_or_self_t {
 504     bool self;
 505     Ttcn::Reference *reference;
 506   } runs_on_compref_or_self;
 507
 508   struct {
 509     visibility_t visibility;
 510   } visbilitytype;
 511 }
 512
 513 /* Tokens of TTCN-3 */
 514
 515 /*********************************************************************
 516  * Tokens with semantic value
 517  *********************************************************************/
 518
 519 /* Terminals with semantic value  */
 520
 521 %token <int_val> Number
 522 %token <float_val> FloatValue
 523 %token <id> IDentifier "Identifier"
 524
 525 %token <string_val> Bstring
 526   Hstring
 527   Ostring
 528   BitStringMatch
 529   HexStringMatch
 530   OctetStringMatch
 531 %token <str> Cstring
 532 %token NullValue "ASN.1_NULL_value"
 533 %token <macrotype> MacroValue
 534
 535 /*********************************************************************
 536  * Tokens without semantic value
 537  *********************************************************************/
 538
 539 /* Terminals without semantic value - keywords, operators, etc. */
 540
 541 %token TOK_errval "erroneous_value"
 542
 543 /* A number of terminals (including ApplyKeyword, CallOpKeyword, etc)
 544  * are listed as unused by Bison. They do not appear in any rule,
 545  * because the lexer does some magic to combine them with the preceding dot
 546  * and returns a (DotApplyKeyword, DotCallOpKeyword, etc) instead.
 547  * This magic requires the presence of the unused keywords.
 548  * (It can return an ApplyKeyword if not preceded by a dot) */
 549 %token TitanErroneousHackKeyword
 550 %token ActionKeyword
 551 %token ActivateKeyword
 552 %token AddressKeyword
 553 %token AliveKeyword
 554 %token AllKeyword
 555 %token AltKeyword
 556 %token AltstepKeyword
 557 %token AndKeyword
 558 %token And4bKeyword
 559 %token AnyKeyword
 560 %token AnyTypeKeyword
 561 %token ApplyKeyword
 562 %token BitStringKeyword
 563 %token BooleanKeyword
 564 %token BreakKeyword
 565 %token CallOpKeyword
 566 %token CaseKeyword
 567 %token CatchOpKeyword
 568 %token CharKeyword
 569 %token CharStringKeyword
 570 %token CheckOpKeyword
 571 %token ClearOpKeyword
 572 %token ComplementKeyword
 573 %token ComponentKeyword
 574 %token ConnectKeyword
 575 %token ConstKeyword
 576 %token ContinueKeyword
 577 %token ControlKeyword
 578 %token CreateKeyword
 579 %token DeactivateKeyword
 580 %token DefaultKeyword
 581 %token DerefersKeyword
 582 %token DisconnectKeyword
 583 %token DisplayKeyword
 584 %token DoKeyword
 585 %token DoneKeyword
 586 %token ElseKeyword
 587 %token EncodeKeyword
 588 %token EnumKeyword
 589 %token ErrorKeyword
 590 %token ExceptKeyword
 591 %token ExceptionKeyword
 592 %token ExecuteKeyword
 593 %token ExtendsKeyword
 594 %token ExtensionKeyword
 595 %token ExtKeyword
 596 %token FailKeyword
 597 %token FalseKeyword
 598 %token FloatKeyword
 599 %token ForKeyword
 600 %token FriendKeyword
 601 %token FromKeyword
 602 %token FunctionKeyword
 603 %token GetCallOpKeyword
 604 %token GetReplyOpKeyword
 605 %token GetVerdictKeyword
 606 %token GotoKeyword
 607 %token GroupKeyword
 608 %token HaltKeyword
 609 %token HexStringKeyword
 610 %token IfKeyword
 611 %token IfPresentKeyword
 612 %token ImportKeyword
 613 %token InconcKeyword
 614 %token InfinityKeyword
 615 %token InOutParKeyword
 616 %token InParKeyword
 617 %token IntegerKeyword
 618 %token InterleavedKeyword
 619 %token KillKeyword
 620 %token KilledKeyword
 621 %token LabelKeyword
 622 %token LanguageKeyword
 623 %token LengthKeyword
 624 %token LogKeyword
 625 %token MapKeyword
 626 %token MatchKeyword
 627 %token MessageKeyword
 628 %token MixedKeyword
 629 %token ModKeyword
 630 %token ModifiesKeyword
 631 %token ModuleParKeyword
 632 %token MTCKeyword
 633 %token NaNKeyword
 634 %token NoBlockKeyword
 635 %token NoneKeyword
 636 %token NotKeyword
 637 %token Not4bKeyword
 638 %token NowaitKeyword
 639 %token NullKeyword
 640 %token ObjectIdentifierKeyword
 641 %token OctetStringKeyword
 642 %token OfKeyword
 643 %token OmitKeyword
 644 %token OnKeyword
 645 %token OptionalKeyword
 646 %token OrKeyword
 647 %token Or4bKeyword
 648 %token OutParKeyword
 649 %token OverrideKeyword
 650 %token PassKeyword
 651 %token ParamKeyword
 652 %token PatternKeyword
 653 %token PermutationKeyword
 654 %token PresentKeyword
 655 %token PortKeyword
 656 %token PrivateKeyword
 657 %token ProcedureKeyword
 658 %token PublicKeyword
 659 %token RaiseKeyword
 660 %token ReadKeyword
 661 %token ReceiveOpKeyword
 662 %token RecordKeyword
 663 %token RecursiveKeyword
 664 %token RefersKeyword
 665 %token RemKeyword
 666 %token RepeatKeyword
 667 %token ReplyKeyword
 668 %token ReturnKeyword
 669 %token RunningKeyword
 670 %token RunsKeyword
 671 %token SelectKeyword
 672 %token SelfKeyword
 673 %token SenderKeyword
 674 %token SendOpKeyword
 675 %token SetKeyword
 676 %token SetVerdictKeyword
 677 %token SignatureKeyword
 678 %token StartKeyword
 679 %token StopKeyword
 680 %token SubsetKeyword
 681 %token SupersetKeyword
 682 %token SystemKeyword
 683 %token TemplateKeyword
 684 %token TestcaseKeyword
 685 %token TimeoutKeyword
 686 %token TimerKeyword
 687 %token ToKeyword
 688 %token TriggerOpKeyword
 689 %token TrueKeyword
 690 %token TTCN3ModuleKeyword
 691 %token TypeDefKeyword
 692 %token UnionKeyword
 693 %token UniversalKeyword
 694 %token UnmapKeyword
 695 %token ValueKeyword
 696 %token ValueofKeyword
 697 %token VarKeyword
 698 %token VariantKeyword
 699 %token VerdictTypeKeyword
 700 %token WhileKeyword
 701 %token WithKeyword
 702 %token XorKeyword
 703 %token Xor4bKeyword
 704
 705 /* TITAN specific keywords */
 706 %token TitanSpecificTryKeyword
 707 %token TitanSpecificCatchKeyword
 708 %token TitanSpecificLazyKeyword
 709
 710 /* Keywords combined with a leading dot */
 711
 712 /* If a '.' (dot) character is followed by one of the keywords below the
 713  * lexical analyzer shall return one combined token instead of two distinct
 714  * tokens. This eliminates the ambiguity that causes additional shift/reduce
 715  * conflicts because the dot can be either the part of a field reference or a
 716  * built-in operation denoted by a keyword. */
 717
 718 %token DotAliveKeyword
 719 %token DotApplyKeyword
 720 %token DotCallOpKeyword
 721 %token DotCatchOpKeyword
 722 %token DotCheckOpKeyword
 723 %token DotClearOpKeyword
 724 %token DotCreateKeyword
 725 %token DotDoneKeyword
 726 %token DotGetCallOpKeyword
 727 %token DotGetReplyOpKeyword
 728 %token DotHaltKeyword
 729 %token DotKillKeyword
 730 %token DotKilledKeyword
 731 %token DotRaiseKeyword
 732 %token DotReadKeyword
 733 %token DotReceiveOpKeyword
 734 %token DotReplyKeyword
 735 %token DotRunningKeyword
 736 %token DotSendOpKeyword
 737 %token DotStartKeyword
 738 %token DotStopKeyword
 739 %token DotTimeoutKeyword
 740 %token DotTriggerOpKeyword
 741
 742 /* Predefined function identifiers */
 743
 744 %token bit2hexKeyword
 745 %token bit2intKeyword
 746 %token bit2octKeyword
 747 %token bit2strKeyword
 748 %token char2intKeyword
 749 %token char2octKeyword
 750 %token decompKeyword
 751 %token float2intKeyword
 752 %token hex2bitKeyword
 753 %token hex2intKeyword
 754 %token hex2octKeyword
 755 %token hex2strKeyword
 756 %token int2bitKeyword
 757 %token int2charKeyword
 758 %token int2floatKeyword
 759 %token int2hexKeyword
 760 %token int2octKeyword
 761 %token int2strKeyword
 762 %token int2unicharKeyword
 763 %token isvalueKeyword
 764 %token isboundKeyword
 765 %token ischosenKeyword
 766 %token ispresentKeyword
 767 %token lengthofKeyword
 768 %token oct2bitKeyword
 769 %token oct2charKeyword
 770 %token oct2hexKeyword
 771 %token oct2intKeyword
 772 %token oct2strKeyword
 773 %token oct2unicharKeyword
 774 %token regexpKeyword
 775 %token replaceKeyword
 776 %token rndKeyword
 777 %token testcasenameKeyword
 778 %token sizeofKeyword
 779 %token str2floatKeyword
 780 %token str2intKeyword
 781 %token str2octKeyword
 782 %token substrKeyword
 783 %token unichar2intKeyword
 784 %token unichar2charKeyword
 785 %token unichar2octKeyword
 786
 787 %token float2strKeyword
 788 %token str2bitKeyword
 789 %token str2hexKeyword
 790
 791 %token log2strKeyword
 792 %token enum2intKeyword
 793
 794 %token encvalueKeyword
 795 %token decvalueKeyword
 796
 797 %token ttcn2stringKeyword
 798 %token string2ttcnKeyword
 799 %token remove_bomKeyWord
 800 %token get_stringencodingKeyWord
 801 %token encode_base64KeyWord
 802 %token decode_base64KeyWord
 803
 804 /* Multi-character operators */
 805
 806 %token AssignmentChar ":="
 807 %token DotDot ".."
 808 %token PortRedirectSymbol "->"
 809 %token EQ "=="
 810 %token NE "!="
 811 %token GE ">="
 812 %token LE "<="
 813 %token SL "<<"
 814 %token SR ">>"
 815 %token RL "<@"
 816 %token _RR "@>" /* Name clash with bn.h:292 */
 817
 818 /*********************************************************************
 819  * Semantic types of nonterminals
 820  *********************************************************************/
 821
 822 %type <bool_val> optAliveKeyword optOptionalKeyword optOverrideKeyword
 823   optErrValueRaw optAllKeyword optLazyEval
 824 %type <str> FreeText optLanguageSpec PatternChunk PatternChunkList
 825 %type <uchar_val> Group Plane Row Cell
 826 %type <id> FieldIdentifier FieldReference GlobalModuleId
 827   IdentifierOrAddressKeyword StructFieldRef PredefOrIdentifier
 828 %type <string_val> CstringList
 829 %type <ustring_val> Quadruple
 830
 831 %type <typetype> PredefinedType
 832 %type <portoperationmode> PortOperationMode
 833 %type <operationtype> PredefinedOpKeyword1 PredefinedOpKeyword2 PredefinedOpKeyword3
 834
 835 %type <activateop> ActivateOp
 836 %type <attribtype> AttribKeyword
 837
 838 %type <altguard> CallBodyStatement AltGuard ElseStatement GuardStatement
 839   InterleavedGuardElement
 840 %type <altguards> AltGuardList CallBodyStatementList InterleavedGuardList
 841   optPortCallBody
 842 %type <arraydimension> ArrayIndex
 843 %type <attributespec> AttribSpec
 844 %type <compbody> optComponentDefList ComponentElementDefList
 845 %type <compfield> StructFieldDef UnionFieldDef
 846 %type <compfieldmap> StructFieldDefList optStructFieldDefList UnionFieldDefList
 847 %type <definition> AltstepDef ExtFunctionDef FunctionDef TemplateDef TestcaseDef
 848 %type <deftype> TypeDefBody StructuredTypeDef SubTypeDef RecordDef UnionDef
 849   SetDef RecordOfDef SetOfDef EnumDef PortDef PortDefBody ComponentDef
 850   TypeDef SignatureDef FunctionTypeDef AltstepTypeDef TestcaseTypeDef
 851 %type <deftimer> SingleTimerInstance
 852 %type <enumitem> Enumeration
 853 %type <enumitems> EnumerationList
 854 %type <fieldorarrayref> ArrayOrBitRef ArrayOrBitRefOrDash FieldOrArrayReference
 855 %type <formalpar> FormalValuePar FormalTemplatePar FormalTimerPar
 856   TemplateFormalPar FunctionFormalPar TestcaseFormalPar
 857 %type <formalparlist> optTemplateFormalParList TemplateFormalParList
 858   optFunctionFormalParList FunctionFormalParList optTestcaseFormalParList
 859   TestcaseFormalParList optAltstepFormalParList
 860 %type <group> GroupDef GroupIdentifier
 861 %type <friend_list> FriendModuleDef
 862 %type <ifclause> ElseIfClause
 863 %type <ifclauses> seqElseIfClause
 864 %type <impmod> ImportFromSpec ModuleId ImportDef
 865 %type <lenrestr> optStringLength LengthMatch StringLength
 866 %type <logarg> LogItem
 867 %type <logargs> LogItemList
 868 %type <multiwithattrib> MultiWithAttrib WithAttribList WithStatement
 869   optWithStatement optWithStatementAndSemiColon
 870 %type <namedtempl> FieldSpec
 871 %type <namedtempls> seqFieldSpec
 872 %type <namedvalue> FieldExpressionSpec
 873 %type <namedvalues> seqFieldExpressionSpec
 874 %type <indexedtempl> ArraySpec
 875 %type <indexedtempls> seqArraySpec
 876 %type <indexedvalue> ArrayExpressionSpec
 877 %type <oidcomp> NumberForm NameAndNumberForm ObjIdComponent
 878 %type <parass> VariableAssignment
 879 %type <parasss> AssignmentList
 880 %type <parredir> ParamAssignmentList ParamSpec
 881 %type <patstr> CharStringMatch
 882 %type <qualifier> DefOrFieldRef FullGroupIdentifier
 883 %type <qualifiers> DefOrFieldRefList optAttribQualifier
 884 %type <selectcase> SelectCase
 885 %type <selectcases> seqSelectCase SelectCaseBody
 886 %type <signexc> ExceptionTypeList optExceptionSpec
 887 %type <signparam> SignatureFormalPar
 888 %type <signparamlist> SignatureFormalParList optSignatureFormalParList
 889 %type <singlewithattrib> SingleWithAttrib
 890 %type <stmt> AltConstruct BasicStatements BreakStatement BehaviourStatements
 891   CallBodyOps CallStatement CatchStatement CheckStatement ClearStatement
 892   CommunicationStatements ConditionalConstruct ConfigurationStatements
 893   ConnectStatement ContinueStatement ControlStatement DeactivateStatement
 894   DisconnectStatement DoWhileStatement DoneStatement ForStatement
 895   FunctionStatement GetCallStatement GetReplyStatement GotoStatement GuardOp
 896   HaltStatement InterleavedConstruct KillTCStatement KilledStatement
 897   LabelStatement LogStatement LoopConstruct MapStatement RaiseStatement
 898   ReceiveStatement RepeatStatement ReplyStatement ReturnStatement SUTStatements
 899   SendStatement SetLocalVerdict StartStatement StartTCStatement
 900   StartTimerStatement StopExecutionStatement StopStatement StopTCStatement
 901   StopTimerStatement TimeoutStatement TimerStatements TriggerStatement
 902   UnmapStatement VerdictStatements WhileStatement SelectCaseConstruct
 903   StopTestcaseStatement String2TtcnStatement
 904 %type <statementblock> StatementBlock optElseClause FunctionStatementOrDefList
 905   ControlStatementOrDefList ModuleControlBody
 906 %type <subtypeparse> ValueOrRange
 907 %type <templ> MatchingSymbol SingleValueOrAttrib SimpleSpec TemplateBody
 908   ArrayElementSpec ArrayValueOrAttrib FieldSpecList ArraySpecList
 909   AllElementsFrom TemplateListElem
 910 %type <templinst> AddressRef FromClause FunctionActualPar InLineTemplate
 911   ReceiveParameter SendParameter TemplateActualPar TemplateInstance
 912   /* TestcaseActualPar */ ValueMatchSpec optFromClause optParDefaultValue
 913   optReceiveParameter
 914 %type <parsedpar> FunctionActualParList TestcaseActualParList
 915   optFunctionActualParList optTestcaseActualParList
 916   NamedPart UnnamedPart
 917 %type <templinsts>  optTemplateActualParList
 918   seqTemplateActualPar seqTemplateInstance
 919 %type <templs> ValueOrAttribList seqValueOrAttrib ValueList Complement
 920   ArrayElementSpecList SubsetMatch SupersetMatch PermutationMatch
 921 %type <ass> Assignment Step
 922 %type <refbase> DerivedRefWithParList TemplateRefWithParList DecValueArg
 923 %type <refpard> FunctionInstance AltstepInstance
 924 %type <reference> PortType optDerivedDef DerivedDef Signature VariableRef
 925   TimerRef TimerRefOrAny Port PortOrAny PortOrAll ValueSpec
 926   SenderSpec ComponentType optRunsOnSpec RunsOnSpec optSystemSpec
 927 %type <valuerange> Range
 928 %type <type> NestedEnumDef NestedRecordDef NestedRecordOfDef NestedSetDef
 929   NestedSetOfDef NestedTypeDef NestedUnionDef PortDefAttribs ReferencedType
 930   Type TypeOrNestedTypeDef NestedFunctionTypeDef NestedAltstepTypeDef
 931   NestedTestcaseTypeDef
 932 %type <types> TypeList AllOrTypeList
 933 %type <value> AddressValue AliveOp AllPortsSpec AltGuardChar ArrayBounds
 934   ArrayExpression ArrayExpressionList BitStringValue BooleanExpression
 935   BooleanValue CharStringValue ComponentRef ComponentReferenceOrLiteral
 936   ComponentOrDefaultReference CompoundExpression ConfigurationOps CreateOp
 937   DereferOp Expression FieldExpressionList Final GetLocalVerdict HexStringValue
 938   IntegerValue LowerBound MTCOp MatchOp NotUsedOrExpression ObjIdComponentList
 939   ObjectIdentifierValue OctetStringValue OmitValue OpCall PredefinedOps
 940   PredefinedValue ReadTimerOp ReferOp ReferencedValue RunningOp RunningTimerOp
 941   SelfOp SingleExpression SingleLowerBound SystemOp TemplateOps TimerOps
 942   TimerValue UpperBound Value ValueofOp VerdictOps VerdictValue optReplyValue
 943   optTestcaseTimerValue optToClause
 944 %type <values> ArrayElementExpressionList seqArrayExpressionSpec
 945 %type <variableentries> VariableList
 946 %type <variableentry> VariableEntry
 947 %type <subtypeparses> seqValueOrRange AllowedValues optSubTypeSpec
 948
 949 %type <arraydimension_list> optArrayDef
 950 %type <fieldorarrayref_list> optExtendedFieldReference
 951 %type <def_list> AltstepLocalDef AltstepLocalDefList ComponentElementDef
 952   ConstDef ExtConstDef FunctionLocalDef FunctionLocalInst ModuleDef ModulePar
 953   ModuleParDef MultiTypedModuleParList PortInstance TimerInstance TimerList
 954   VarInstance
 955 %type <stmt_list> FunctionStatementOrDef ControlStatementOrDef
 956
 957 %type <rangedef> RangeDef
 958 %type <returntype> optReturnType
 959 %type <returntypeornoblock> optReturnTypeOrNoBlockKeyword
 960 %type <structdefbody> StructDefBody UnionDefBody
 961 %type <structofdefbody> StructOfDefBody
 962 %type <portdefbody> PortDefList seqPortDefList PortDefLists
 963 %type <ischosenarg> IschosenArg
 964 %type <extramatchingattrs> optExtraMatchingAttributes
 965 %type <basetemplate> BaseTemplate
 966 %type <templateref> TemplateRef TestcaseRef FunctionRef
 967 %type <testcaseinst> TestcaseInstance
 968 %type <portsendop> PortSendOp
 969 %type <calltimerval> CallTimerValue
 970 %type <portcallop> PortCallOp CallParameters
 971 %type <portreplyop> PortReplyOp
 972 %type <portraiseop> PortRaiseOp
 973 %type <portredirect> optPortRedirect
 974 %type <portredirectwithparam> optPortRedirectWithParam
 975 %type <portredirectwithvalueandparam> optPortRedirectWithValueAndParam
 976 %type <getreplypar> optGetReplyParameter
 977 %type <portreceiveop> PortReceiveOp PortTriggerOp
 978 %type <portgetcallop> PortGetCallOp
 979 %type <portgetreplyop> PortGetReplyOp
 980 %type <catchoppar> optCatchOpParameter CatchOpParameter
 981 %type <portcatchop> PortCatchOp
 982 %type <portcheckop> optCheckParameter CheckParameter CheckPortOpsPresent
 983   FromClausePresent RedirectPresent
 984 %type <portref> PortRef AllConnectionsSpec
 985 %type <connspec> SingleConnectionSpec SingleOrMultiConnectionSpec
 986 %type <donepar> optDoneParameter
 987 %type <reforid> Reference
 988 %type <initial> Initial
 989 %type <configspec> ConfigSpec
 990 %type <createpar> optCreateParameter
 991 %type <applyop> ApplyOp
 992 %type <identifier_list> IdentifierList
 993 %type <singlevarinst> SingleConstDef SingleVarInstance
 994 %type <singlevarinst_list> ConstList VarList
 995 %type <singletempvarinst> SingleTempVarInstance
 996 %type <singletempvarinst_list> TempVarList
 997 %type <singlemodulepar> SingleModulePar
 998 %type <singletemplatemodulepar> SingleTemplateModulePar
 999 %type <singlemodulepar_list> ModuleParList
1000 %type <singletemplatemodulepar_list> TemplateModuleParList
1001 %type <portelement> PortElement
1002 %type <portelement_list> PortElementList
1003 %type <comprefs> optExtendsDef ComponentTypeList
1004 %type <runs_on_compref_or_self> optRunsOnComprefOrSelf
1005 %type <template_restriction> TemplateRestriction optTemplateRestriction
1006   TemplateOptRestricted
1007 %type <visbilitytype> optVisibility ComponentElementVisibility
1008 %type <float_val> FloatOrSpecialFloatValue
1009 %type <erroneous_indicator> ErroneousIndicator
1010 %type <imptype> ImportSpec ImportElement
1011
1012 /*********************************************************************
1013  * Destructors
1014  *********************************************************************/
1015
1016 %destructor {
1017   act_group = $$->get_parent_group();
1018 }
1019 GroupDef
1020 GroupIdentifier
1021
1022 %destructor {Free($$);}
1023 Cstring
1024 FreeText
1025 optLanguageSpec
1026 PatternChunk
1027 PatternChunkList
1028
1029 %destructor {
1030   delete $$.ref_pard;
1031   delete $$.derefered_value;
1032   delete $$.ap_list;
1033 }
1034 ActivateOp
1035
1036 %destructor {delete $$;}
1037 AddressRef
1038 AddressValue
1039 AliveOp
1040 AllOrTypeList
1041 AllPortsSpec
1042 AltConstruct
1043 AltGuard
1044 AltGuardChar
1045 AltGuardList
1046 AltstepDef
1047 AltstepInstance
1048 AltstepTypeDef
1049 ArrayBounds
1050 ArrayElementExpressionList
1051 ArrayElementSpec
1052 ArrayElementSpecList
1053 ArrayExpression
1054 ArrayIndex
1055 ArrayOrBitRef
1056 ArrayOrBitRefOrDash
1057 ArrayValueOrAttrib
1058 Assignment
1059 AssignmentList
1060 AttribSpec
1061 BasicStatements
1062 BehaviourStatements
1063 BitStringMatch
1064 BitStringValue
1065 BooleanExpression
1066 BooleanValue
1067 BreakStatement
1068 Bstring
1069 CallBodyOps
1070 CallBodyStatement
1071 CallBodyStatementList
1072 CallStatement
1073 CatchStatement
1074 CharStringMatch
1075 CharStringValue
1076 CheckStatement
1077 ClearStatement
1078 CommunicationStatements
1079 Complement
1080 ComponentDef
1081 ComponentElementDefList
1082 ComponentOrDefaultReference
1083 ComponentRef
1084 ComponentReferenceOrLiteral
1085 ComponentType
1086 ComponentTypeList
1087 CompoundExpression
1088 ConditionalConstruct
1089 ConfigurationOps
1090 ConfigurationStatements
1091 ConnectStatement
1092 ContinueStatement
1093 ControlStatement
1094 ControlStatementOrDefList
1095 CreateOp
1096 DeactivateStatement
1097 DefOrFieldRef
1098 DefOrFieldRefList
1099 DereferOp
1100 DerivedDef
1101 DerivedRefWithParList
1102 DisconnectStatement
1103 DoWhileStatement
1104 DoneStatement
1105 ElseIfClause
1106 ElseStatement
1107 EnumDef
1108 Enumeration
1109 EnumerationList
1110 ExceptionTypeList
1111 Expression
1112 FieldExpressionList
1113 FieldExpressionSpec
1114 FieldIdentifier
1115 FieldOrArrayReference
1116 FieldReference
1117 FieldSpec
1118 FieldSpecList
1119 Final
1120 ForStatement
1121 FormalTemplatePar
1122 FormalTimerPar
1123 FormalValuePar
1124 FromClause
1125 FullGroupIdentifier
1126 FunctionActualPar
1127 FunctionActualParList
1128 FunctionDef
1129 FunctionFormalPar
1130 FunctionFormalParList
1131 FunctionInstance
1132 FunctionStatement
1133 FunctionStatementOrDefList
1134 FunctionTypeDef
1135 GetCallStatement
1136 GetLocalVerdict
1137 GetReplyStatement
1138 GlobalModuleId
1139 GotoStatement
1140 GuardOp
1141 GuardStatement
1142 HaltStatement
1143 HexStringMatch
1144 HexStringValue
1145 Hstring
1146 IDentifier
1147 IdentifierOrAddressKeyword
1148 ImportFromSpec
1149 InLineTemplate
1150 IntegerValue
1151 InterleavedConstruct
1152 InterleavedGuardElement
1153 InterleavedGuardList
1154 KillTCStatement
1155 KilledStatement
1156 LabelStatement
1157 LengthMatch
1158 LogItem
1159 LogItemList
1160 LogStatement
1161 String2TtcnStatement
1162 LoopConstruct
1163 LowerBound
1164 MTCOp
1165 MapStatement
1166 MatchOp
1167 MatchingSymbol
1168 ModuleControlBody
1169 ModuleId
1170 MultiWithAttrib
1171 NamedPart
1172 NameAndNumberForm
1173 NestedAltstepTypeDef
1174 NestedEnumDef
1175 NestedFunctionTypeDef
1176 NestedRecordDef
1177 NestedRecordOfDef
1178 NestedSetDef
1179 NestedSetOfDef
1180 NestedTestcaseTypeDef
1181 NestedTypeDef
1182 NestedUnionDef
1183 NotUsedOrExpression
1184 Number
1185 NumberForm
1186 ObjIdComponent
1187 ObjIdComponentList
1188 ObjectIdentifierValue
1189 OctetStringMatch
1190 OctetStringValue
1191 OmitValue
1192 OpCall
1193 Ostring
1194 ParamAssignmentList
1195 ParamSpec
1196 PermutationMatch
1197 Port
1198 PortDef
1199 PortDefAttribs
1200 PortDefBody
1201 PortOrAll
1202 PortOrAny
1203 PortType
1204 PredefOrIdentifier
1205 PredefinedOps
1206 PredefinedValue
1207 RaiseStatement
1208 Range
1209 ReadTimerOp
1210 ReceiveParameter
1211 ReceiveStatement
1212 RecordDef
1213 RecordOfDef
1214 ReferOp
1215 ReferencedType
1216 ReferencedValue
1217 RepeatStatement
1218 ReplyStatement
1219 ReturnStatement
1220 RunningOp
1221 RunningTimerOp
1222 RunsOnSpec
1223 SUTStatements
1224 SelfOp
1225 SendParameter
1226 SendStatement
1227 SenderSpec
1228 SetDef
1229 SetLocalVerdict
1230 SetOfDef
1231 Signature
1232 SignatureDef
1233 SignatureFormalPar
1234 SignatureFormalParList
1235 SimpleSpec
1236 SingleExpression
1237 SingleLowerBound
1238 SingleTimerInstance
1239 SingleValueOrAttrib
1240 SingleWithAttrib
1241 DecValueArg
1242 StartStatement
1243 StartTCStatement
1244 StartTimerStatement
1245 StatementBlock
1246 Step
1247 StopExecutionStatement
1248 StopTestcaseStatement
1249 StopStatement
1250 StopTCStatement
1251 StopTimerStatement
1252 StringLength
1253 StructFieldDef
1254 StructFieldDefList
1255 StructFieldRef
1256 StructuredTypeDef
1257 SubTypeDef
1258 SubsetMatch
1259 SupersetMatch
1260 SystemOp
1261 TemplateActualPar
1262 TemplateBody
1263 TemplateDef
1264 TemplateFormalPar
1265 TemplateFormalParList
1266 TemplateInstance
1267 TemplateOps
1268 TemplateRefWithParList
1269 /* TestcaseActualPar */
1270 TestcaseActualParList
1271 TestcaseDef
1272 TestcaseFormalPar
1273 TestcaseFormalParList
1274 TestcaseTypeDef
1275 TimeoutStatement
1276 TimerOps
1277 TimerRef
1278 TimerRefOrAny
1279 TimerStatements
1280 TimerValue
1281 TriggerStatement
1282 Type
1283 TypeDef
1284 TypeDefBody
1285 TypeList
1286 TypeOrNestedTypeDef
1287 UnionDef
1288 UnionFieldDef
1289 UnionFieldDefList
1290 UnmapStatement
1291 UnnamedPart
1292 UpperBound
1293 Value
1294 ValueList
1295 ValueMatchSpec
1296 ValueOrAttribList
1297 ValueOrRange
1298 ValueSpec
1299 ValueofOp
1300 VariableAssignment
1301 VariableEntry
1302 VariableList
1303 VariableRef
1304 VerdictOps
1305 VerdictStatements
1306 VerdictValue
1307 WhileStatement
1308 WithAttribList
1309 WithStatement
1310 optAltstepFormalParList
1311 optAttribQualifier
1312 optComponentDefList
1313 optDerivedDef
1314 optElseClause
1315 optExceptionSpec
1316 optExtendsDef
1317 optFromClause
1318 optFunctionActualParList
1319 optFunctionFormalParList
1320 optParDefaultValue
1321 optPortCallBody
1322 optReceiveParameter
1323 optReplyValue
1324 optRunsOnSpec
1325 optSignatureFormalParList
1326 optStringLength
1327 optStructFieldDefList
1328 optSystemSpec
1329 optTemplateActualParList
1330 optTemplateFormalParList
1331 optTestcaseActualParList
1332 optTestcaseFormalParList
1333 optTestcaseTimerValue
1334 optToClause
1335 optWithStatement
1336 optWithStatementAndSemiColon
1337 seqElseIfClause
1338 seqFieldExpressionSpec
1339 seqFieldSpec
1340 seqTemplateActualPar
1341 seqTemplateInstance
1342 seqValueOrAttrib
1343 Quadruple
1344
1345 %destructor {
1346   for (size_t i = 0; i < $$->size(); i++) delete (*$$)[i];
1347   $$->clear();
1348   delete $$;
1349 }
1350 AllowedValues
1351 optSubTypeSpec
1352 seqValueOrRange
1353
1354 %destructor {
1355   for(size_t i=0; i<$$.nElements; i++) delete $$.elements[i];
1356   Free($$.elements);
1357 }
1358 AltstepLocalDef
1359 AltstepLocalDefList
1360 ComponentElementDef
1361 ConstDef
1362 ControlStatementOrDef
1363 ExtConstDef
1364 FunctionLocalDef
1365 FunctionLocalInst
1366 FunctionStatementOrDef
1367 ModuleDef
1368 ModulePar
1369 ModuleParDef
1370 MultiTypedModuleParList
1371 PortInstance
1372 TimerInstance
1373 TimerList
1374 VarInstance
1375 optArrayDef
1376 optExtendedFieldReference
1377 FriendModuleDef
1378
1379 %destructor {
1380   delete $$.lower;
1381   delete $$.upper;
1382 }
1383 RangeDef
1384
1385 %destructor {
1386   delete $$.type;
1387 }
1388 optReturnType
1389 optReturnTypeOrNoBlockKeyword
1390
1391 %destructor {
1392   delete $$.id;
1393   delete $$.cfm;
1394 }
1395 StructDefBody
1396 UnionDefBody
1397
1398 %destructor {
1399   delete $$.type;
1400   delete $$.id;
1401 }
1402 StructOfDefBody
1403
1404 %destructor {
1405   delete $$.in_list;
1406   delete $$.out_list;
1407   delete $$.inout_list;
1408 }
1409 PortDefList
1410 PortDefLists
1411 seqPortDefList
1412
1413 %destructor {
1414   delete $$.ref;
1415   delete $$.id;
1416 }
1417 IschosenArg
1418
1419 %destructor {
1420   delete $$.len_restr;
1421 }
1422 optExtraMatchingAttributes
1423
1424 %destructor {
1425   delete $$.name;
1426   delete $$.type;
1427   delete $$.fp_list;
1428 }
1429 BaseTemplate
1430
1431 %destructor {
1432   delete $$.modid;
1433   delete $$.id;
1434 }
1435 FunctionRef
1436 TemplateRef
1437 TestcaseRef
1438
1439 %destructor {
1440   delete $$.ref_pard;
1441   delete $$.derefered_value;
1442   delete $$.ap_list;
1443   delete $$.value;
1444 }
1445 TestcaseInstance
1446
1447 %destructor {
1448   delete $$.templ_inst;
1449   delete $$.val;
1450 }
1451 PortSendOp
1452
1453 %destructor {
1454   delete $$.calltimerval;
1455 }
1456 CallTimerValue
1457
1458 %destructor {
1459   delete $$.templ_inst;
1460   delete $$.calltimerval;
1461   delete $$.val;
1462 }
1463 PortCallOp CallParameters
1464
1465 %destructor {
1466   delete $$.templ_inst;
1467   delete $$.replyval;
1468   delete $$.toclause;
1469 }
1470 PortReplyOp
1471
1472 %destructor {
1473   delete $$.signature;
1474   delete $$.templ_inst;
1475   delete $$.toclause;
1476 }
1477 PortRaiseOp
1478
1479 %destructor {
1480   delete $$.redirectval;
1481   delete $$.redirectsender;
1482 }
1483 optPortRedirect
1484
1485 %destructor {
1486   delete $$.redirectparam;
1487   delete $$.redirectsender;
1488 }
1489 optPortRedirectWithParam
1490
1491 %destructor {
1492   delete $$.redirectval;
1493   delete $$.redirectparam;
1494   delete $$.redirectsender;
1495 }
1496 optPortRedirectWithValueAndParam
1497
1498 %destructor {
1499   delete $$.templ_inst;
1500   delete $$.valuematch;
1501 }
1502 optGetReplyParameter
1503
1504 %destructor {
1505   delete $$.templ_inst;
1506   delete $$.fromclause;
1507   delete $$.redirectval;
1508   delete $$.redirectsender;
1509 }
1510 PortReceiveOp
1511 PortTriggerOp
1512
1513 %destructor {
1514   delete $$.templ_inst;
1515   delete $$.fromclause;
1516   delete $$.redirectparam;
1517   delete $$.redirectsender;
1518 }
1519 PortGetCallOp
1520
1521 %destructor {
1522   delete $$.templ_inst;
1523   delete $$.valuematch;
1524   delete $$.fromclause;
1525   delete $$.redirectval;
1526   delete $$.redirectparam;
1527   delete $$.redirectsender;
1528 }
1529 PortGetReplyOp
1530
1531 %destructor {
1532   delete $$.signature;
1533   delete $$.templ_inst;
1534 }
1535 optCatchOpParameter
1536 CatchOpParameter
1537
1538 %destructor {
1539   delete $$.signature;
1540   delete $$.templ_inst;
1541   delete $$.fromclause;
1542   delete $$.redirectval;
1543   delete $$.redirectsender;
1544 }
1545 PortCatchOp
1546
1547 %destructor {
1548   delete $$.signature;
1549   delete $$.templ_inst;
1550   delete $$.valuematch;
1551   delete $$.fromclause;
1552   delete $$.redirectval;
1553   delete $$.redirectparam;
1554   delete $$.redirectsender;
1555 }
1556 optCheckParameter
1557 CheckParameter
1558 CheckPortOpsPresent
1559 FromClausePresent
1560 RedirectPresent
1561
1562 %destructor {
1563   delete $$.compref;
1564   delete $$.portref;
1565 }
1566 PortRef
1567 AllConnectionsSpec
1568
1569 %destructor {
1570   delete $$.compref1;
1571   delete $$.portref1;
1572   delete $$.compref2;
1573   delete $$.portref2;
1574 }
1575 SingleConnectionSpec
1576 SingleOrMultiConnectionSpec
1577
1578 %destructor {
1579   delete $$.donematch;
1580   delete $$.redirect;
1581 }
1582 optDoneParameter
1583
1584 %destructor {
1585   if ($$.is_ref) delete $$.ref;
1586   else delete $$.id;
1587 }
1588 Reference
1589
1590 %destructor {
1591   delete $$.defs;
1592   delete $$.ass;
1593 }
1594 Initial
1595
1596 %destructor {
1597   delete $$.runsonref;
1598   delete $$.systemref;
1599 }
1600 ConfigSpec
1601
1602 %destructor {
1603   delete $$.name;
1604   delete $$.loc;
1605 }
1606 optCreateParameter
1607
1608 %destructor {
1609   delete $$.value;
1610   delete $$.ap_list;
1611 }
1612 ApplyOp
1613
1614 %destructor {
1615   for (size_t i = 0; i < $$.nElements; i++) delete $$.elements[i].id;
1616   Free($$.elements);
1617 }
1618 IdentifierList
1619
1620 %destructor {
1621   delete $$.id;
1622   for (size_t i = 0; i < $$.arrays.nElements; i++)
1623     delete $$.arrays.elements[i];
1624   Free($$.arrays.elements);
1625   delete $$.initial_value;
1626 }
1627 SingleConstDef
1628 SingleVarInstance
1629 SingleTempVarInstance
1630
1631 %destructor {
1632   for (size_t i = 0; i < $$.nElements; i++) {
1633     delete $$.elements[i].id;
1634     for (size_t j = 0; i < $$.elements[i].arrays.nElements; j++)
1635       delete $$.elements[i].arrays.elements[j];
1636     Free($$.elements[i].arrays.elements);
1637     delete $$.elements[i].initial_value;
1638   }
1639   Free($$.elements);
1640 }
1641 ConstList
1642 TempVarList
1643 VarList
1644
1645 %destructor {
1646   delete $$.id;
1647   delete $$.defval;
1648 }
1649 SingleModulePar
1650
1651 %destructor {
1652   delete $$.id;
1653   delete $$.deftempl;
1654 }
1655 SingleTemplateModulePar
1656
1657 %destructor {
1658   for (size_t i = 0; i < $$.nElements; i++) {
1659     delete $$.elements[i].id;
1660     delete $$.elements[i].defval;
1661   }
1662   Free($$.elements);
1663 }
1664 ModuleParList
1665
1666 %destructor {
1667   for (size_t i = 0; i < $$.nElements; i++) {
1668     delete $$.elements[i].id;
1669     delete $$.elements[i].deftempl;
1670   }
1671   Free($$.elements);
1672 }
1673 TemplateModuleParList
1674
1675 %destructor {
1676   delete $$.id;
1677   delete $$.dims;
1678 }
1679 PortElement
1680
1681 %destructor {
1682   for (size_t i = 0; i < $$.nElements; i++) {
1683     delete $$.elements[i].id;
1684     delete $$.elements[i].dims;
1685   }
1686   Free($$.elements);
1687 }
1688 PortElementList
1689
1690 %destructor {
1691   delete $$.reference;
1692 }
1693 optRunsOnComprefOrSelf
1694
1695 /*********************************************************************
1696  * Operator precedences (lowest first)
1697  *********************************************************************/
1698
1699 %left OrKeyword
1700 %left XorKeyword
1701 %left AndKeyword
1702 %left NotKeyword
1703 %left EQ NE
1704 %nonassoc '<' '>' GE LE
1705 %left SL SR RL _RR
1706 %left Or4bKeyword
1707 %left Xor4bKeyword
1708 %left And4bKeyword
1709 %left Not4bKeyword
1710 %left '+' '-' '&'
1711 %left '*' '/' ModKeyword RemKeyword
1712 %left UnarySign
1713
1714 %expect 24
1715
1716 %start GrammarRoot
1717
1718 /*
1719 XXX Source of conflicts (24 S/R):
1720
1721 1.) 8 conflicts in one state
1722 The Expression after 'return' keyword is optional in ReturnStatement.
1723 For 8 tokens the parser cannot decide whether the token is a part of
1724 the return expression (shift) or it is the beginning of the next statement
1725 (reduce).
1726
1727 2.) 8 distinct states, each with one conflict caused by token '['
1728 The local definitions in altsteps can be followed immediately by the guard
1729 expression. When the parser sees the '[' token it cannot decide whether it
1730 belongs to the local definition as array dimension or array subreference
1731 (shift) or it is the beginning of the first guard expression (reduce).
1732 The situations are the following:
1733 - var t v := ref <here> [
1734 - var t v := ref[subref] <here> [
1735 - var t v := ref.integer <here> [
1736 - var t v := ref.subref <here> [
1737 - timer t <here> [
1738 - var t v <here> [
1739 - var t v := ref.objid{...}.subref <here> [
1740 - var template t v <here> [
1741
1742 3.) 1 conflict
1743 The sequence identifier.objid can be either the beginning of a module name
1744 qualified with a module object identifier (shift) or a reference to an objid
1745 value within an entity of type anytype (reduce).
1746
1747 4.) 1 conflict
1748 The '{' token after a call statement can be either the part of the response and
1749 exception handling part (shift) or the beginning of the next statement, which
1750 is a StatementBlock (reduce). Note that StatementBlock as a statement is a
1751 non-standard language extension.
1752
1753 5.) 5 conflicts in in three states, related to named parameters
1754
1755 6.) 1 Conflict due to pattern concatenation
1756
1757 Note that the parser implemented by bison always chooses to shift instead of
1758 reduce in case of conflicts. This is the desired behaviour in situations 1.),
1759 2.) and 4.) since the opposite alternative can be forced by the correct usage
1760 of semi-colons. Situation 3.) does not cause any problems as anytype is not
1761 supported at the moment.
1762 */
1763
1764 %%
1765
1766 /*********************************************************************
1767  * Grammar
1768  *********************************************************************/
1769
1770 /* The grammar of TTCN-3 */
1771 /* The numbers correspond to ES 201 873-1 V4.1.2 (2009-07) */
1772
1773 GrammarRoot:
1774   TTCN3Module
1775   {
1776     if (is_erroneous_parsed) {
1777       delete act_ttcn3_module;
1778       act_ttcn3_module = NULL;
1779       Location loc(infile, @1);
1780       loc.error("The erroneous attribute cannot be a TTCN-3 module.");
1781     }
1782   }
1783 | TitanErroneousHackKeyword ErroneousAttributeSpec
1784   {
1785     if (!is_erroneous_parsed) {
1786       delete act_ttcn3_erroneous_attr_spec;
1787       act_ttcn3_erroneous_attr_spec = NULL;
1788       Location loc(infile, @$);
1789       loc.error("File `%s' does not contain a TTCN-3 module.", infile);
1790     }
1791   }
1792 | error
1793 ;
1794
1795 ErroneousAttributeSpec:
1796   ErroneousIndicator AssignmentChar TemplateInstance optAllKeyword
1797   {
1798     act_ttcn3_erroneous_attr_spec = new ErroneousAttributeSpec($1.is_raw, $1.indicator, $3, $4);
1799   }
1800 ;
1801
1802 ErroneousIndicator:
1803   ValueKeyword optErrValueRaw
1804   {
1805     $$.indicator = ErroneousAttributeSpec::I_VALUE;
1806     $$.is_raw = $2;
1807   }
1808 | IDentifier optErrValueRaw
1809   {
1810     if ($1->get_ttcnname()=="before") $$.indicator = ErroneousAttributeSpec::I_BEFORE;
1811     else if ($1->get_ttcnname()=="after") $$.indicator = ErroneousAttributeSpec::I_AFTER;
1812     else {
1813       Location loc(infile, @1);
1814       loc.error("Invalid indicator. Valid indicators are: "
1815                 "`before', `value' and `after'");
1816       $$.indicator = ErroneousAttributeSpec::I_INVALID;
1817     }
1818     delete $1;
1819     $$.is_raw = $2;
1820   }
1821 ;
1822
1823 optAllKeyword:
1824   /* empty */ { $$ = false; }
1825 | AllKeyword { $$ = true; }
1826 ;
1827
1828 optErrValueRaw:
1829   /* empty */ { $$ = false; }
1830 | '(' IDentifier ')'
1831   {
1832     if ($2->get_ttcnname()=="raw") $$ = true;
1833     else {
1834       Location loc(infile, @2);
1835       loc.error("Invalid keyword, only the optional `raw' keyword can be used here.");
1836       $$ = false;
1837     }
1838     delete $2;
1839   }
1840 ;
1841
1842
1843 /* A.1.6.0 TTCN Module */
1844
1845 TTCN3Module: // 1
1846   TTCN3ModuleId ModuleBody optWithStatementAndSemiColon optError
1847   {
1848     act_ttcn3_module->set_with_attr($3);
1849     if (anytype_access) {
1850       // If there was an attempted access to an anytype field, artificially
1851       // create a type definition as if the following appeared in TTCN-3:
1852       // type union anytype { /* empty, members added later */ }
1853       // NOTE: anything which looks like usage of an anytype field will bring
1854       // the local anytype to life, which trumps any imported anytype
1855       // (when resolving, the local anytype will be found first).
1856       // TODO: just to be safe, anytype should be removed from the exports.
1857       Type *t = new Type(Type::T_ANYTYPE);
1858       Identifier *anytype_id = new Identifier(Identifier::ID_TTCN, anyname);
1859       Def_Type *anytypedef = new Def_Type(anytype_id, t);
1860       anytypedef->set_parent_path(act_ttcn3_module->get_attrib_path());
1861       act_ttcn3_module->add_ass(anytypedef);
1862       // Def_Type is-a Definition is-a Assignment
1863     }
1864   }
1865 ;
1866
1867 TTCN3ModuleId: // 3
1868   optError TTCN3ModuleKeyword IDentifier optDefinitiveIdentifier
1869   optLanguageSpec optError
1870   {
1871     act_ttcn3_module = new Ttcn::Module($3);
1872     act_ttcn3_module->set_scope_name($3->get_dispname());
1873     act_ttcn3_module->set_language_spec($5);
1874     Free($5);
1875   }
1876 ;
1877
1878 ModuleId: // 4
1879   GlobalModuleId optLanguageSpec
1880   {
1881     $$ = new ImpMod($1);
1882     $$->set_language_spec($2);
1883     Free($2);
1884   }
1885 ;
1886
1887 GlobalModuleId: // 5
1888   IDentifier { $$ = $1; }
1889 | IDentifier '.' ObjectIdentifierValue
1890   { $$ = $1; delete $3; }
1891 ;
1892
1893 optLanguageSpec:
1894   /* empty */ { $$ = NULL; }
1895 | LanguageKeyword FreeText { $$ = $2; } // sort-of 7 LanguageSpec
1896 ;
1897
1898 ModuleBody:
1899   '{' optErrorBlock '}'
1900 | '{' ModuleDefinitionsList optErrorBlock '}'
1901 | '{' ModuleDefinitionsList ModuleControlPart optErrorBlock '}'
1902 | '{' ModuleControlPart optErrorBlock '}'
1903 ;
1904
1905 /* A.1.6.1 Module definitions part */
1906
1907 /* A.1.6.1.0 General */
1908
1909 ModuleDefinitionsList: // 10
1910   ModuleDefinition optSemiColon
1911 | error ModuleDefinition optSemiColon
1912 | ModuleDefinitionsList optErrorBlock ModuleDefinition optSemiColon
1913 ;
1914
1915 optVisibility: // 12
1916 //  /* empty */ { $$.visibility = PUBLIC;}
1917 /* empty */     { $$.visibility = NOCHANGE;}
1918 | PublicKeyword { $$.visibility = PUBLIC;}
1919 | PrivateKeyword { $$.visibility = PRIVATE;}
1920 | FriendKeyword { $$.visibility = FRIEND;}
1921 ;
1922
1923 /* A definition _in_ the module, not a definition _of_ a module */
1924 ModuleDefinition: // 11
1925   optVisibility ModuleDef optWithStatement
1926   {
1927     for (size_t i = 0; i < $2.nElements; i++) {
1928       if ($3) {
1929         if (i == 0) $2.elements[i]->set_with_attr($3);
1930         else $2.elements[i]->set_with_attr($3->clone());
1931       }
1932       if ($1.visibility != NOCHANGE) {
1933         $2.elements[i]->set_visibility($1.visibility);
1934       }
1935       act_ttcn3_module->add_ass($2.elements[i]);
1936       if (act_group) {
1937         $2.elements[i]->set_parent_path(act_group->get_attrib_path());
1938         act_group->add_ass($2.elements[i]);
1939       } else {
1940         $2.elements[i]->set_parent_path(act_ttcn3_module->get_attrib_path());
1941       }
1942     }
1943     Free($2.elements);
1944   }
1945 | optVisibility ImportDef optWithStatement
1946   {
1947     $2->set_with_attr($3);
1948     if ($1.visibility != NOCHANGE) {
1949       $2->set_visibility($1.visibility);
1950     }
1951     if (act_group) {
1952       $2->set_parent_path(act_group->get_attrib_path());
1953       act_group->add_impmod($2);
1954     } else {
1955       $2->set_parent_path(act_ttcn3_module->get_attrib_path());
1956     }
1957     act_ttcn3_module->add_impmod($2);
1958   }
1959 | PublicKeyword GroupDef optWithStatement
1960   { // only public allowed for group, and it's redundant
1961     $2->set_with_attr($3);
1962     act_group = $2->get_parent_group();
1963   }
1964 | GroupDef optWithStatement
1965   { // same code as above
1966     $1->set_with_attr($2);
1967     act_group = $1->get_parent_group();
1968   }
1969 | PrivateKeyword FriendModuleDef optWithStatement
1970   { // only private allowed for "friend module", and it's redundant
1971     for (size_t i = 0; i < $2.nElements; i++) {
1972       if ($3) {
1973         if (i == 0) $2.elements[i]->set_with_attr($3);
1974         else $2.elements[i]->set_with_attr($3->clone());
1975       }
1976       act_ttcn3_module->add_friendmod($2.elements[i]);
1977       if (act_group) {
1978         $2.elements[i]->set_parent_path(act_group->get_attrib_path());
1979         act_group->add_friendmod($2.elements[i]);
1980       } else {
1981         $2.elements[i]->set_parent_path(act_ttcn3_module->get_attrib_path());
1982       }
1983     }
1984     Free($2.elements);
1985   }
1986 | FriendModuleDef optWithStatement
1987   { // same code as above
1988     for (size_t i = 0; i < $1.nElements; i++) {
1989       if ($2) {
1990         if (i == 0) $1.elements[i]->set_with_attr($2);
1991         else $1.elements[i]->set_with_attr($2->clone());
1992       }
1993       act_ttcn3_module->add_friendmod($1.elements[i]);
1994       if (act_group) {
1995         $1.elements[i]->set_parent_path(act_group->get_attrib_path());
1996         act_group->add_friendmod($1.elements[i]);
1997       } else {
1998         $1.elements[i]->set_parent_path(act_ttcn3_module->get_attrib_path());
1999       }
2000     }
2001     Free($1.elements);
2002   }
2003 ;
2004
2005 ModuleDef:
2006   ConstDef { $$ = $1; }
2007 | ModuleParDef { $$ = $1; }
2008 | TypeDef
2009   {
2010     $$.nElements = 1;
2011     $$.elements = (Ttcn::Definition**)
2012       Malloc(sizeof(*$$.elements));
2013     $$.elements[0] = $1;
2014   }
2015 | TemplateDef
2016   {
2017     $$.nElements = 1;
2018     $$.elements = (Ttcn::Definition**)
2019       Malloc(sizeof(*$$.elements));
2020     $$.elements[0] = $1;
2021   }
2022 | FunctionDef
2023   {
2024     $$.nElements = 1;
2025     $$.elements = (Ttcn::Definition**)
2026       Malloc(sizeof(*$$.elements));
2027     $$.elements[0] = $1;
2028   }
2029 | SignatureDef
2030   {
2031     $$.nElements = 1;
2032     $$.elements = (Ttcn::Definition**)
2033       Malloc(sizeof(*$$.elements));
2034     $$.elements[0] = $1;
2035   }
2036 | TestcaseDef
2037   {
2038     $$.nElements = 1;
2039     $$.elements = (Ttcn::Definition**)
2040       Malloc(sizeof(*$$.elements));
2041     $$.elements[0] = $1;
2042   }
2043 | AltstepDef
2044   {
2045     $$.nElements = 1;
2046     $$.elements = (Ttcn::Definition**)
2047       Malloc(sizeof(*$$.elements));
2048     $$.elements[0] = $1;
2049   }
2050 | ExtFunctionDef
2051   {
2052     $$.nElements = 1;
2053     $$.elements = (Ttcn::Definition**)
2054       Malloc(sizeof(*$$.elements));
2055     $$.elements[0] = $1;
2056   }
2057 | ExtConstDef { $$ = $1; }
2058 ;
2059
2060 /* A.1.6.1.1 Typedef definitions */
2061
2062 TypeDef: // 13
2063   TypeDefKeyword TypeDefBody
2064   {
2065     $$ = $2;
2066     $$->set_location(infile, @$);
2067   }
2068 ;
2069
2070 TypeDefBody: // 14
2071   StructuredTypeDef { $$ = $1; }
2072 | SubTypeDef { $$ = $1; }
2073 ;
2074
2075 StructuredTypeDef: // 16
2076   RecordDef { $$ = $1; }
2077 | UnionDef { $$ = $1; }
2078 | SetDef { $$ = $1; }
2079 | RecordOfDef { $$ = $1; }
2080 | SetOfDef { $$ = $1; }
2081 | EnumDef { $$ = $1; }
2082 | PortDef { $$ = $1; }
2083 | ComponentDef { $$ = $1; }
2084 | FunctionTypeDef { $$ = $1; }
2085 | AltstepTypeDef { $$ = $1; }
2086 | TestcaseTypeDef { $$ = $1; }
2087 ;
2088
2089 RecordDef: // 17
2090   RecordKeyword StructDefBody
2091   {
2092     Type *type = new Type(Type::T_SEQ_T, $2.cfm);
2093     type->set_location(infile, @$);
2094     $$ = new Def_Type($2.id, type);
2095   }
2096 ;
2097
2098 StructDefBody: // 19
2099   IDentifier optStructDefFormalParList
2100   '{' optStructFieldDefList '}'
2101   {
2102     $$.id = $1;
2103     $$.cfm = $4;
2104   }
2105 | AddressKeyword '{' optStructFieldDefList '}'
2106   {
2107     $$.id = new Identifier(Identifier::ID_TTCN, string("address"));
2108     $$.cfm = $3;
2109   }
2110 ;
2111
2112 optStructDefFormalParList:
2113   /* empty */ optError
2114 | '(' StructDefFormalParList optError ')'
2115   {
2116     Location loc(infile, @$);
2117     loc.error("Type parameterization is not currently supported");
2118   }
2119 | '(' error ')'
2120   {
2121     Location loc(infile, @$);
2122     loc.error("Type parameterization is not currently supported");
2123   }
2124 ;
2125
2126 StructDefFormalParList: // -> 202 784 "Advanced Parameterization", 9
2127   optError StructDefFormalPar
2128 | StructDefFormalParList optError ',' optError StructDefFormalPar
2129 | StructDefFormalParList optError ',' error
2130 ;
2131
2132 StructDefFormalPar: // -> 202 784 "Advanced Parameterization", 10
2133   FormalValuePar { delete $1; }
2134 ;
2135
2136 optStructFieldDefList:
2137   /* empty */ optError { $$ = new CompFieldMap; }
2138 | StructFieldDefList optError { $$ = $1; }
2139 ;
2140
2141 StructFieldDefList:
2142   optError StructFieldDef
2143   {
2144     $$ = new CompFieldMap;
2145     $$->add_comp($2);
2146   }
2147 | StructFieldDefList optError ',' optError StructFieldDef
2148   {
2149     $$ = $1;
2150     $$->add_comp($5);
2151   }
2152 | StructFieldDefList optError ',' error { $$ = $1; }
2153 ;
2154
2155 StructFieldDef: // 21
2156   TypeOrNestedTypeDef IDentifier optArrayDef optSubTypeSpec optOptionalKeyword
2157   {
2158     if ($4) {
2159       /* The subtype constraint belongs to the innermost embedded type of
2160        * possible nested 'record of' or 'set of' constructs. */
2161       Type *t = $1;
2162       while (t->is_seof()) t = t->get_ofType();
2163       t->set_parsed_restrictions($4);
2164     }
2165     Type *type = $1;
2166     /* creation of array type(s) if necessary (from right to left) */
2167     for (size_t i = $3.nElements; i > 0; i--) {
2168       type = new Type(Type::T_ARRAY, type, $3.elements[i - 1], true);
2169       type->set_location(*$1);
2170     }
2171     Free($3.elements);
2172     $$ = new CompField($2, type, $5);
2173     $$->set_location(infile, @$);
2174   }
2175 ;
2176
2177 optOptionalKeyword:
2178   /* empty */ { $$ = false; }
2179 | OptionalKeyword { $$ = true; }
2180 ;
2181
2182 TypeOrNestedTypeDef:
2183   Type { $$ = $1; }
2184 | NestedTypeDef { $$ = $1; }
2185 ;
2186
2187 NestedTypeDef: // 22
2188   NestedRecordDef { $$ = $1; }
2189 | NestedUnionDef { $$ = $1; }
2190 | NestedSetDef { $$ = $1; }
2191 | NestedRecordOfDef { $$ = $1; }
2192 | NestedSetOfDef { $$ = $1; }
2193 | NestedEnumDef { $$ = $1; }
2194 | NestedFunctionTypeDef { $$ = $1; }
2195 | NestedAltstepTypeDef { $$ = $1; }
2196 | NestedTestcaseTypeDef { $$ = $1; }
2197 ;
2198
2199 NestedRecordDef: // 23
2200   RecordKeyword '{' optStructFieldDefList '}'
2201   {
2202     $$ = new Type(Type::T_SEQ_T, $3);
2203     $$->set_location(infile, @$);
2204   }
2205 ;
2206
2207 NestedUnionDef: // 24
2208   UnionKeyword '{' UnionFieldDefList optError '}'
2209   {
2210     $$ = new Type(Type::T_CHOICE_T, $3);
2211     $$->set_location(infile, @$);
2212   }
2213 ;
2214
2215 NestedSetDef:  // 25
2216   SetKeyword '{' optStructFieldDefList '}'
2217   {
2218     $$ = new Type(Type::T_SET_T, $3);
2219     $$->set_location(infile, @$);
2220   }
2221 ;
2222
2223 NestedRecordOfDef: // 26
2224   RecordKeyword optStringLength OfKeyword TypeOrNestedTypeDef
2225   {
2226     $$ = new Type(Type::T_SEQOF, $4);
2227     if ($2) {
2228       vector<SubTypeParse> *vstp = new vector<SubTypeParse>;
2229       SubTypeParse *stp = new SubTypeParse($2);
2230       vstp->add(stp);
2231       $$->set_parsed_restrictions(vstp);
2232     }
2233     $$->set_location(infile, @$);
2234   }
2235 ;
2236
2237 NestedSetOfDef: // 27
2238   SetKeyword optStringLength OfKeyword TypeOrNestedTypeDef
2239   {
2240     $$ = new Type(Type::T_SETOF, $4);
2241     if ($2) {
2242       vector<SubTypeParse> *vstp = new vector<SubTypeParse>;
2243       SubTypeParse *stp = new SubTypeParse($2);
2244       vstp->add(stp);
2245       $$->set_parsed_restrictions(vstp);
2246     }
2247     $$->set_location(infile, @$);
2248   }
2249 ;
2250
2251 NestedEnumDef: // 28
2252   EnumKeyword '{' EnumerationList optError '}'
2253   {
2254     $$ = new Type(Type::T_ENUM_T, $3);
2255     $$->set_location(infile, @$);
2256   }
2257 ;
2258
2259 NestedFunctionTypeDef:
2260   FunctionKeyword '(' optFunctionFormalParList ')'
2261   optRunsOnComprefOrSelf optReturnType
2262   {
2263     $3->set_location(infile, @2, @4);
2264     $$ = new Type(Type::T_FUNCTION, $3, $5.reference, $5.self, $6.type,
2265                   $6.returns_template, $6.template_restriction);
2266     $$->set_location(infile, @$);
2267   }
2268 ;
2269
2270 NestedAltstepTypeDef:
2271   AltstepKeyword '(' optAltstepFormalParList ')'
2272   optRunsOnComprefOrSelf
2273   {
2274     $3->set_location(infile, @2, @4);
2275     $$ = new Type(Type::T_ALTSTEP, $3, $5.reference, $5.self);
2276     $$->set_location(infile, @$);
2277   }
2278 ;
2279
2280 NestedTestcaseTypeDef:
2281   TestcaseKeyword '(' optTestcaseFormalParList ')'
2282   ConfigSpec
2283   {
2284     $3->set_location(infile, @2, @4);
2285     $$ = new Type(Type::T_TESTCASE, $3, $5.runsonref,
2286                           $5.systemref);
2287     $$->set_location(infile, @$);
2288   }
2289 ;
2290
2291 UnionDef: // 31
2292   UnionKeyword UnionDefBody
2293   {
2294     Type *type = new Type(Type::T_CHOICE_T, $2.cfm);
2295     type->set_location(infile, @$);
2296     $$ = new Def_Type($2.id, type);
2297   }
2298 ;
2299
2300 UnionDefBody: // 33
2301   IDentifier optStructDefFormalParList
2302   '{' UnionFieldDefList optError '}'
2303   {
2304     $$.id = $1;
2305     $$.cfm = $4;
2306   }
2307 | AddressKeyword '{' UnionFieldDefList optError '}'
2308   {
2309     $$.id = new Identifier(Identifier::ID_TTCN, string("address"));
2310     $$.cfm = $3;
2311   }
2312 ;
2313
2314 UnionFieldDefList:
2315   optError UnionFieldDef
2316   {
2317     $$ = new CompFieldMap;
2318     $$->add_comp($2);
2319   }
2320 | UnionFieldDefList optError ',' optError UnionFieldDef
2321   {
2322     $$ = $1;
2323     $$->add_comp($5);
2324   }
2325 | UnionFieldDefList optError ',' error { $$ = $1; }
2326 | error { $$ = new CompFieldMap; }
2327 ;
2328
2329 UnionFieldDef: // 34
2330   TypeOrNestedTypeDef IDentifier optArrayDef optSubTypeSpec
2331   {
2332     if ($4) {
2333       /* The subtype constraint belongs to the innermost embedded type of
2334        * possible nested 'record of' or 'set of' constructs. */
2335       Type *t = $1;
2336       while (t->is_seof()) t = t->get_ofType();
2337       t->set_parsed_restrictions($4);
2338     }
2339     Type *type = $1;
2340     /* creation of array type(s) if necessary (from right to left) */
2341     for (size_t i = $3.nElements; i > 0; i--) {
2342       type = new Type(Type::T_ARRAY, type, $3.elements[i - 1], true);
2343       type->set_location(*$1);
2344     }
2345     Free($3.elements);
2346     $$ = new CompField($2, type, false);
2347     $$->set_location(infile, @$);
2348   }
2349 ;
2350
2351 SetDef: // 35
2352   SetKeyword StructDefBody
2353   {
2354     Type *type = new Type(Type::T_SET_T, $2.cfm);
2355     type->set_location(infile, @$);
2356     $$ = new Def_Type($2.id, type);
2357   }
2358 ;
2359
2360 RecordOfDef: // 37
2361   RecordKeyword optStringLength OfKeyword StructOfDefBody
2362   {
2363     Type *type = new Type(Type::T_SEQOF, $4.type);
2364     if ($2) {
2365       vector<SubTypeParse> *vstp = new vector<SubTypeParse>;
2366       vstp->add(new SubTypeParse($2));
2367       type->set_parsed_restrictions(vstp);
2368     }
2369     type->set_location(infile, @$);
2370     $$ = new Def_Type($4.id, type);
2371   }
2372 ;
2373
2374 StructOfDefBody: // 39
2375   TypeOrNestedTypeDef IdentifierOrAddressKeyword optSubTypeSpec
2376   {
2377     if ($3) {
2378       /* The subtype constraint belongs to the innermost embedded type of
2379        * possible nested 'record of' or 'set of' constructs. */
2380       Type *t = $1;
2381       while (t->is_seof()) t = t->get_ofType();
2382       t->set_parsed_restrictions($3);
2383     }
2384     $$.type = $1;
2385     $$.id = $2;
2386   }
2387 ;
2388
2389 IdentifierOrAddressKeyword:
2390   IDentifier { $$ = $1; }
2391 | AddressKeyword
2392   {
2393     $$ = new Identifier(Identifier::ID_TTCN, string("address"));
2394   }
2395 ;
2396
2397 SetOfDef: // 40
2398   SetKeyword optStringLength OfKeyword StructOfDefBody
2399   {
2400     Type *type = new Type(Type::T_SETOF, $4.type);
2401     if ($2) {
2402       vector<SubTypeParse> *vstp = new vector<SubTypeParse>;
2403       vstp->add(new SubTypeParse($2));
2404       type->set_parsed_restrictions(vstp);
2405     }
2406     type->set_location(infile, @$);
2407     $$ = new Def_Type($4.id, type);
2408   }
2409 ;
2410
2411 EnumDef: // 41
2412   EnumKeyword IdentifierOrAddressKeyword
2413   '{' EnumerationList optError '}'
2414   {
2415     Type *type = new Type(Type::T_ENUM_T, $4);
2416     type->set_location(infile, @$);
2417     $$ = new Def_Type($2, type);
2418   }
2419 ;
2420
2421 EnumerationList: // 44
2422   optError Enumeration
2423   {
2424     $$ = new EnumItems;
2425     $$->add_ei($2);
2426   }
2427 | EnumerationList optError ',' optError Enumeration
2428   {
2429     $$ = $1;
2430     $$->add_ei($5);
2431   }
2432 | EnumerationList optError ',' error { $$ = $1; }
2433 | error { $$ = new EnumItems; }
2434 ;
2435
2436 Enumeration: // 45
2437   IDentifier
2438   {
2439     $$ = new EnumItem($1, NULL);
2440     $$->set_location(infile, @$);
2441   }
2442 | IDentifier '(' Number optError ')'
2443   {
2444     Value *value = new Value(Value::V_INT, $3);
2445     value->set_location(infile, @3);
2446     $$ = new EnumItem($1, value);
2447     $$->set_location(infile, @$);
2448   }
2449 | IDentifier '(' '-' Number optError ')'
2450   {
2451     *$4 = -*$4;
2452     Value *value = new Value(Value::V_INT, $4);
2453     value->set_location(infile, @3, @4);
2454     $$ = new EnumItem($1, value);
2455     $$->set_location(infile, @$);
2456   }
2457 | IDentifier '(' error ')'
2458   {
2459     Value *value = new Value(Value::V_ERROR);
2460     value->set_location(infile, @3);
2461     $$ = new EnumItem($1, value);
2462     $$->set_location(infile, @$);
2463   }
2464 ;
2465
2466 SubTypeDef: // 47
2467   Type IdentifierOrAddressKeyword optArrayDef optSubTypeSpec
2468   {
2469     /* the subtype constraint belongs to the innermost type */
2470     if ($4) $1->set_parsed_restrictions($4);
2471     Type *type = $1;
2472     /* creation of array type(s) if necessary (from right to left) */
2473     for (size_t i = $3.nElements; i > 0; i--) {
2474       type = new Type(Type::T_ARRAY, type, $3.elements[i - 1], true);
2475       type->set_location(*$1);
2476     }
2477     Free($3.elements);
2478     $$ = new Def_Type($2, type);
2479   }
2480 ;
2481
2482 optSubTypeSpec: // [49]
2483   /* empty */ { $$ = 0; }
2484 | AllowedValues { $$ = $1; }
2485 | AllowedValues StringLength
2486   {
2487     $$ = $1;
2488     $$->add(new SubTypeParse($2));
2489   }
2490 | StringLength
2491   {
2492     $$ = new vector<SubTypeParse>;
2493     $$->add(new SubTypeParse($1));
2494   }
2495 ;
2496
2497 AllowedValues: // 50
2498   '(' seqValueOrRange optError ')' { $$ = $2; }
2499   | '(' CharStringMatch optError ')'
2500   {
2501     $$ = new vector<SubTypeParse>;
2502     $$->add(new SubTypeParse($2));
2503   }
2504   | '(' error ')' { $$ = new vector<SubTypeParse>; }
2505 ;
2506
2507 seqValueOrRange:
2508   optError ValueOrRange
2509   {
2510     $$ = new vector<SubTypeParse>;
2511     $$->add($2);
2512   }
2513 | seqValueOrRange optError ',' optError ValueOrRange
2514   {
2515     $$ = $1;
2516     $$->add($5);
2517   }
2518 | seqValueOrRange optError ',' error { $$ = $1; }
2519 ;
2520
2521 ValueOrRange: // 51
2522   RangeDef { $$ = new SubTypeParse($1.lower, $1.lower_exclusive, $1.upper, $1.upper_exclusive); }
2523 | Expression { $$ = new SubTypeParse($1); }
2524 ;
2525
2526 RangeDef: // 52
2527   LowerBound DotDot UpperBound
2528   {
2529     $$.lower_exclusive = false;
2530     $$.lower = $1;
2531     $$.upper_exclusive = false;
2532     $$.upper = $3;
2533   }
2534 | '!' LowerBound DotDot UpperBound
2535   {
2536     $$.lower_exclusive = true;
2537     $$.lower = $2;
2538     $$.upper_exclusive = false;
2539     $$.upper = $4;
2540   }
2541 | LowerBound DotDot '!' UpperBound
2542   {
2543     $$.lower_exclusive = false;
2544     $$.lower = $1;
2545     $$.upper_exclusive = true;
2546     $$.upper = $4;
2547   }
2548 | '!' LowerBound DotDot '!' UpperBound
2549   {
2550     $$.lower_exclusive = true;
2551     $$.lower = $2;
2552     $$.upper_exclusive = true;
2553     $$.upper = $5;
2554   }
2555 ;
2556
2557 optStringLength:
2558   /* empty */ optError { $$ = 0; }
2559 | StringLength { $$ = $1; }
2560 ;
2561
2562 StringLength: // 53
2563   LengthKeyword '(' Expression optError ')'
2564   {
2565     $$ = new LengthRestriction($3);
2566     $$->set_location(infile, @$);
2567   }
2568 | LengthKeyword '(' Expression DotDot UpperBound optError ')'
2569   {
2570     $$ = new LengthRestriction($3, $5);
2571     $$->set_location(infile, @$);
2572   }
2573 | LengthKeyword '(' error ')'
2574   {
2575     Value *value = new Value(Value::V_ERROR);
2576     value->set_location(infile, @3);
2577     $$ = new LengthRestriction(value);
2578     $$->set_location(infile, @$);
2579   }
2580 ;
2581
2582 PortType: // 55
2583   IDentifier
2584   {
2585     $$ = new Ttcn::Reference($1);
2586     $$->set_location(infile, @$);
2587   }
2588 | IDentifier '.' IDentifier
2589   {
2590     $$ = new Ttcn::Reference($1, $3);
2591     $$->set_location(infile, @$);
2592   }
2593 | IDentifier '.' ObjectIdentifierValue '.' IDentifier
2594   {
2595     $$ = new Ttcn::Reference($1, $5);
2596     $$->set_location(infile, @$);
2597     delete $3;
2598   }
2599 ;
2600
2601 PortDef: // 56
2602   PortKeyword PortDefBody { $$ = $2; }
2603 ;
2604
2605 PortDefBody: // 57
2606   IDentifier PortDefAttribs
2607   {
2608     $$ = new Def_Type($1, $2);
2609   }
2610 ;
2611
2612 PortDefAttribs: // 60
2613   PortOperationMode PortDefLists
2614   {
2615     PortTypeBody *body = new PortTypeBody($1,
2616       $2.in_list, $2.out_list, $2.inout_list,
2617       $2.in_all, $2.out_all, $2.inout_all);
2618     body->set_location(infile, @$);
2619     $$ = new Type(Type::T_PORT, body);
2620     $$->set_location(infile, @$);
2621   }
2622 ;
2623
2624 PortOperationMode:
2625   MessageKeyword { $$ = PortTypeBody::PO_MESSAGE; } // 61
2626 | ProcedureKeyword { $$ = PortTypeBody::PO_PROCEDURE; } // 68
2627 | MixedKeyword { $$ = PortTypeBody::PO_MIXED; } // 73
2628 | error { $$ = PortTypeBody::PO_MIXED; }
2629 ;
2630
2631 PortDefLists:
2632   '{' seqPortDefList '}' { $$ = $2; }
2633 | '{' error '}'
2634   {
2635     $$.in_list = 0;
2636     $$.out_list = 0;
2637     $$.inout_list = 0;
2638     $$.in_all = false;
2639     $$.out_all = false;
2640     $$.inout_all = false;
2641   }
2642 ;
2643
2644 seqPortDefList:
2645   optError PortDefList optSemiColon { $$ = $2; }
2646 | seqPortDefList PortDefList optSemiColon
2647   {
2648     $$ = $1;
2649     if ($2.in_list) {
2650       if ($$.in_list) {
2651         $$.in_list->steal_types($2.in_list);
2652         delete $2.in_list;
2653       } else $$.in_list = $2.in_list;
2654     }
2655     if ($2.out_list) {
2656       if ($$.out_list) {
2657         $$.out_list->steal_types($2.out_list);
2658         delete $2.out_list;
2659       } else $$.out_list = $2.out_list;
2660     }
2661     if ($2.inout_list) {
2662       if ($$.inout_list) {
2663         $$.inout_list->steal_types($2.inout_list);
2664         delete $2.inout_list;
2665       } else $$.inout_list = $2.inout_list;
2666     }
2667     if ($2.in_all) {
2668       if ($$.in_all) {
2669         Location loc(infile, @2);
2670         loc.warning("Duplicate directive `in all' in port type definition");
2671       } else $$.in_all = true;
2672     }
2673     if ($2.out_all) {
2674       if ($$.out_all) {
2675         Location loc(infile, @2);
2676         loc.warning("Duplicate directive `out all' in port type definition");
2677       } else $$.out_all = true;
2678     }
2679     if ($2.inout_all) {
2680       if ($$.inout_all) {
2681         Location loc(infile, @2);
2682         loc.warning("Duplicate directive `inout all' in port type definition");
2683       } else $$.inout_all = true;
2684     }
2685   }
2686 ;
2687
2688 PortDefList:
2689   InParKeyword AllOrTypeList
2690   {
2691     if ($2) {
2692       $$.in_list = $2;
2693       $$.in_list->set_location(infile, @$);
2694       $$.in_all = false;
2695     } else {
2696       $$.in_list = 0;
2697       $$.in_all = true;
2698     }
2699     $$.out_list = 0;
2700     $$.out_all = false;
2701     $$.inout_list = 0;
2702     $$.inout_all = false;
2703   }
2704 | OutParKeyword AllOrTypeList
2705   {
2706     $$.in_list = 0;
2707     $$.in_all = false;
2708     if ($2) {
2709       $$.out_list = $2;
2710       $$.out_list->set_location(infile, @$);
2711       $$.out_all = false;
2712     } else {
2713       $$.out_list = 0;
2714       $$.out_all = true;
2715     }
2716     $$.inout_list = 0;
2717     $$.inout_all = false;
2718   }
2719 | InOutParKeyword AllOrTypeList
2720   {
2721     $$.in_list = 0;
2722     $$.in_all = false;
2723     $$.out_list = 0;
2724     $$.out_all = false;
2725     if ($2) {
2726       $$.inout_list = $2;
2727       $$.inout_list->set_location(infile, @$);
2728       $$.inout_all = false;
2729     } else {
2730       $$.inout_list = 0;
2731       $$.inout_all = true;
2732     }
2733   }
2734 | InParKeyword error
2735   {
2736     $$.in_list = 0;
2737     $$.out_list = 0;
2738     $$.inout_list = 0;
2739     $$.in_all = false;
2740     $$.out_all = false;
2741     $$.inout_all = false;
2742   }
2743 | OutParKeyword error
2744   {
2745     $$.in_list = 0;
2746     $$.out_list = 0;
2747     $$.inout_list = 0;
2748     $$.in_all = false;
2749     $$.out_all = false;
2750     $$.inout_all = false;
2751   }
2752 | InOutParKeyword error
2753   {
2754     $$.in_list = 0;
2755     $$.out_list = 0;
2756     $$.inout_list = 0;
2757     $$.in_all = false;
2758     $$.out_all = false;
2759     $$.inout_all = false;
2760   }
2761 ;
2762
2763 AllOrTypeList: // 65
2764   AllKeyword { $$ = 0; }
2765 | TypeList { $$ = $1; }
2766 ;
2767
2768 TypeList: // 67
2769   optError Type
2770   {
2771     $$ = new Types;
2772     $$->add_type($2);
2773   }
2774 | TypeList optError ',' optError Type
2775   {
2776     $$ = $1;
2777     $$->add_type($5);
2778   }
2779 | TypeList optError ',' error { $$ = $1; }
2780 ;
2781
2782 ComponentDef: // 78
2783   ComponentKeyword IDentifier
2784   optExtendsDef
2785   '{' optComponentDefList '}'
2786   {
2787     $5->set_id($2);
2788     if ($3) $5->add_extends($3);
2789     $5->set_location(infile, @$);
2790     Type *type = new Type(Type::T_COMPONENT, $5);
2791     type->set_location(infile, @$);
2792     $$ = new Def_Type($2, type);
2793   }
2794 ;
2795
2796 optExtendsDef:
2797   /* empty */ optError { $$ = 0; }
2798 | ExtendsKeyword ComponentTypeList optError
2799   {
2800     $$ = $2;
2801     $$->set_location(infile, @1, @2);
2802   }
2803 | ExtendsKeyword error { $$ = 0; }
2804 ;
2805
2806 ComponentTypeList:
2807   optError ComponentType
2808   {
2809     $$ = new CompTypeRefList();
2810     $$->add_ref($2);
2811   }
2812 | ComponentTypeList optError ',' optError ComponentType
2813   {
2814     $$ = $1;
2815     $$->add_ref($5);
2816   }
2817 | ComponentTypeList optError ',' error { $$ = $1; }
2818 ;
2819
2820 ComponentType: // 81
2821   IDentifier
2822   {
2823     $$ = new Ttcn::Reference($1);
2824     $$->set_location(infile, @$);
2825   }
2826 | IDentifier '.' IDentifier
2827   {
2828     $$ = new Ttcn::Reference($1, $3);
2829     $$->set_location(infile, @$);
2830   }
2831 | IDentifier '.' ObjectIdentifierValue '.' IDentifier
2832   {
2833     $$ = new Ttcn::Reference($1, $5);
2834     $$->set_location(infile, @$);
2835     delete $3;
2836   }
2837 ;
2838
2839 optComponentDefList:
2840   optError /* empty */ { $$ = new ComponentTypeBody(); }
2841 | ComponentElementDefList optError { $$ = $1; }
2842 ;
2843
2844 ComponentElementDefList:
2845   optError ComponentElementDef optSemiColon
2846   {
2847     $$ = new ComponentTypeBody();
2848     for (size_t i = 0; i < $2.nElements; i++)
2849       $$->add_ass($2.elements[i]);
2850     Free($2.elements);
2851   }
2852 | ComponentElementDefList optError ComponentElementDef optSemiColon
2853   {
2854     $$ = $1;
2855     for (size_t i = 0; i < $3.nElements; i++)
2856       $$->add_ass($3.elements[i]);
2857     Free($3.elements);
2858   }
2859 ;
2860
2861 ComponentElementVisibility:
2862   PublicKeyword { $$.visibility = PUBLIC;}
2863 | PrivateKeyword { $$.visibility = PRIVATE;}
2864 ;
2865
2866 ComponentElementDef: // 84
2867   PortInstance { $$ = $1; }
2868 | VarInstance { $$ = $1; }
2869 | TimerInstance { $$ = $1; }
2870 | ConstDef { $$ = $1; }
2871 | ComponentElementVisibility PortInstance
2872   {
2873     $$ = $2;
2874     for (size_t i = 0; i < $2.nElements; i++) {
2875       $2.elements[i]->set_visibility($1.visibility);
2876     }
2877   }
2878 | ComponentElementVisibility VarInstance
2879   {
2880     $$ = $2;
2881     for (size_t i = 0; i < $2.nElements; i++) {
2882       $2.elements[i]->set_visibility($1.visibility);
2883     }
2884   }
2885 | ComponentElementVisibility TimerInstance
2886   {
2887     $$ = $2;
2888     for (size_t i = 0; i < $2.nElements; i++) {
2889       $2.elements[i]->set_visibility($1.visibility);
2890     }
2891   }
2892 | ComponentElementVisibility ConstDef
2893   {
2894     $$ = $2;
2895     for (size_t i = 0; i < $2.nElements; i++) {
2896       $2.elements[i]->set_visibility($1.visibility);
2897     }
2898   }
2899 ;
2900
2901 PortInstance: // 85
2902   PortKeyword PortType PortElementList
2903   {
2904     $$.nElements = $3.nElements;
2905     $$.elements = (Ttcn::Definition**)
2906       Malloc($$.nElements*sizeof(*$$.elements));
2907     for (size_t i = 0; i < $3.nElements; i++) {
2908       Ttcn::Reference *ref = i > 0 ? $2->clone() : $2;
2909       $$.elements[i] = new Ttcn::Def_Port($3.elements[i].id, ref,
2910                                           $3.elements[i].dims);
2911       $$.elements[i]->set_location(infile, $3.elements[i].yyloc);
2912     }
2913     Free($3.elements);
2914   }
2915 ;
2916
2917 PortElementList:
2918   optError PortElement
2919   {
2920     $$.nElements = 1;
2921     $$.elements = (YYSTYPE::portelement_t*)Malloc(sizeof(*$$.elements));
2922     $$.elements[0] = $2;
2923   }
2924 | PortElementList ',' optError PortElement
2925   {
2926     $$.nElements = $1.nElements + 1;
2927     $$.elements = (YYSTYPE::portelement_t*)
2928       Realloc($1.elements, $$.nElements * sizeof(*$$.elements));
2929     $$.elements[$$.nElements - 1] = $4;
2930   }
2931 | PortElementList ',' error { $$ = $1; }
2932 ;
2933
2934 PortElement: // 86
2935   IDentifier optArrayDef
2936   {
2937     $$.id = $1;
2938     if ($2.nElements > 0) {
2939       $$.dims = new ArrayDimensions;
2940       for (size_t i = 0; i < $2.nElements; i++) $$.dims->add($2.elements[i]);
2941       Free($2.elements);
2942     } else $$.dims = 0;
2943     $$.yyloc = @$;
2944   }
2945 ;
2946
2947 /* A.1.6.1.2 Constant definitions */
2948
2949 ConstDef: // 88
2950   ConstKeyword Type ConstList
2951   {
2952     $$.nElements = $3.nElements;
2953     $$.elements = (Ttcn::Definition**)
2954       Malloc($$.nElements*sizeof(*$$.elements));
2955     for (size_t i = 0; i < $$.nElements; i++) {
2956       Type *type;
2957       if (i > 0) {
2958         type = new Type(Type::T_REFDSPEC, $2);
2959         type->set_location(*$2);
2960       } else type = $2;
2961       /* creation of array type(s) if necessary (from right to left) */
2962       for (size_t j = $3.elements[i].arrays.nElements; j > 0; j--) {
2963         type = new Type(Type::T_ARRAY, type,
2964           $3.elements[i].arrays.elements[j - 1], false);
2965         type->set_location(*$2);
2966       }
2967       Free($3.elements[i].arrays.elements);
2968
2969       /* Create the definition */
2970       $$.elements[i] = new Def_Const($3.elements[i].id,
2971                                      type, $3.elements[i].initial_value);
2972       $$.elements[i]->set_location(infile, $3.elements[i].yyloc);
2973     }
2974     Free($3.elements);
2975   }
2976 ;
2977
2978 ConstList: // 98
2979   optError SingleConstDef
2980   {
2981     $$.nElements = 1;
2982     $$.elements = (YYSTYPE::singlevarinst_t*)Malloc(sizeof(*$$.elements));
2983     $$.elements[0] = $2;
2984   }
2985 | ConstList ',' optError SingleConstDef
2986   {
2987     $$.nElements = $1.nElements + 1;
2988     $$.elements = (YYSTYPE::singlevarinst_t*)
2989       Realloc($1.elements, $$.nElements * sizeof(*$$.elements));
2990     $$.elements[$$.nElements - 1] = $4;
2991   }
2992 ;
2993
2994 SingleConstDef: // 90
2995   IDentifier optArrayDef AssignmentChar Expression
2996   {
2997     $$.id = $1;
2998     $$.arrays = $2;
2999     $$.initial_value = $4;
3000     $$.yyloc = @$;
3001   }
3002 ;
3003
3004 FunctionTypeDef:
3005   FunctionKeyword IDentifier '(' optFunctionFormalParList ')'
3006   optRunsOnComprefOrSelf optReturnType
3007   {
3008     $4->set_location(infile, @3, @5);
3009     Type *type = new Type(Type::T_FUNCTION, $4, $6.reference, $6.self, $7.type,
3010                           $7.returns_template, $7.template_restriction);
3011     type->set_location(infile, @$);
3012     $$ = new Ttcn::Def_Type($2, type);
3013     $$->set_location(infile, @$);
3014   }
3015 ;
3016
3017 AltstepTypeDef:
3018   AltstepKeyword IDentifier '(' optAltstepFormalParList ')'
3019   optRunsOnComprefOrSelf
3020   {
3021     $4->set_location(infile, @3, @5);
3022     Type *type = new Type(Type::T_ALTSTEP, $4, $6.reference, $6.self);
3023     type->set_location(infile, @$);
3024     $$ = new Ttcn::Def_Type($2, type);
3025     $$->set_location(infile, @$);
3026   }
3027 ;
3028
3029 TestcaseTypeDef:
3030   TestcaseKeyword IDentifier '(' optTestcaseFormalParList ')'
3031   ConfigSpec
3032   {
3033     $4->set_location(infile, @3, @5);
3034     Type *type = new Type(Type::T_TESTCASE, $4, $6.runsonref,
3035                           $6.systemref);
3036     type->set_location(infile, @$);
3037     $$ = new Ttcn::Def_Type($2, type);
3038     $$->set_location(infile, @$);
3039   }
3040 ;
3041
3042 /* A.1.6.1.3 Template definitions */
3043
3044 TemplateDef: // 93
3045   TemplateKeyword optTemplateRestriction BaseTemplate
3046   optDerivedDef AssignmentChar TemplateBody
3047   {
3048     $$ = new Def_Template($2, $3.name, $3.type, $3.fp_list, $4, $6);
3049     $$->set_location(infile, @$);
3050   }
3051 ;
3052
3053 BaseTemplate: // 94
3054   Type IDentifier optTemplateFormalParList
3055   {
3056     $$.name = $2;
3057     $$.type = $1;
3058     $$.fp_list = $3;
3059   }
3060 /* | Signature IDentifier optTemplateFormalParList -- covered by the previous
3061    rule */
3062 ;
3063
3064 optDerivedDef:
3065   /* empty */ { $$ = 0; }
3066 | DerivedDef { $$ = $1; }
3067 ;
3068
3069 DerivedDef: // 97
3070   ModifiesKeyword TemplateRef
3071   {
3072     $$ = new Ttcn::Reference($2.modid, $2.id);
3073     $$->set_location(infile, @$);
3074   }
3075 | ModifiesKeyword error { $$ = 0; }
3076 ;
3077
3078 optTemplateFormalParList:
3079   /* empty */ optError { $$ = 0; }
3080 | '(' TemplateFormalParList optError ')'
3081   {
3082     $$ = $2;
3083     $$->set_location(infile, @$);
3084   }
3085 | '(' error ')'
3086   {
3087     $$ = new FormalParList;
3088     $$->set_location(infile, @$);
3089   }
3090 ;
3091
3092 TemplateFormalParList: // 99 is a FormalParList*
3093   optError TemplateFormalPar
3094   {
3095     $$ = new FormalParList;
3096     $$->add_fp($2);
3097   }
3098 | TemplateFormalParList optError ',' optError TemplateFormalPar
3099   {
3100     $$ = $1;
3101     $$->add_fp($5);
3102   }
3103 | TemplateFormalParList optError ',' error { $$ = $1; }
3104 ;
3105
3106 TemplateFormalPar: // 100
3107   FormalValuePar { $$ = $1; }
3108 | FormalTemplatePar { $$ = $1; }
3109 ;
3110
3111 TemplateBody: // 101 is a Template*
3112   SimpleSpec optExtraMatchingAttributes
3113   {
3114     $$ = $1;
3115     $$->set_length_restriction($2.len_restr);
3116     $$->set_ifpresent($2.is_ifpresent);
3117   }
3118 | FieldSpecList optExtraMatchingAttributes
3119   {
3120     $$ = $1;
3121     $$->set_length_restriction($2.len_restr);
3122     $$->set_ifpresent($2.is_ifpresent);
3123   }
3124 | ArraySpecList optExtraMatchingAttributes
3125   {
3126     $$ = $1;
3127     $$->set_length_restriction($2.len_restr);
3128     $$->set_ifpresent($2.is_ifpresent);
3129   }
3130 | ArrayValueOrAttrib optExtraMatchingAttributes
3131   {
3132     $$ = $1;
3133     $$->set_length_restriction($2.len_restr);
3134     $$->set_ifpresent($2.is_ifpresent);
3135   }
3136 ;
3137
3138 SimpleSpec: // 102
3139   SingleValueOrAttrib { $$ = $1; }
3140 ;
3141
3142 FieldSpecList: // 103
3143   '{' '}'
3144   {
3145     $$ = new Template(Template::TEMPLATE_LIST, new Templates());
3146     $$->set_location(infile, @$);
3147
3148   }
3149 | '{' seqFieldSpec optError '}'
3150   {
3151     $$ = new Template($2); // NAMED_TEMLATE_LIST
3152     $$->set_location(infile, @$);
3153   }
3154 | '{' error '}'
3155   {
3156     $$ = new Template(Template::TEMPLATE_ERROR);
3157     $$->set_location(infile, @$);
3158   }
3159 ;
3160
3161 /* Sequence of FieldSpec. \note Cannot be empty */
3162 seqFieldSpec: // a NamedTemplates*
3163   FieldSpec
3164   {
3165     $$ = new NamedTemplates();
3166     $$->add_nt($1);
3167   }
3168 | error FieldSpec
3169   {
3170     $$ = new NamedTemplates();
3171     $$->add_nt($2);
3172   }
3173 | seqFieldSpec optError ',' optError FieldSpec
3174   {
3175     $$=$1;
3176     $$->add_nt($5);
3177   }
3178 | seqFieldSpec optError ',' error { $$ = $1; }
3179 ;
3180
3181 FieldSpec: // 104 a NamedTemplate*
3182   FieldReference AssignmentChar TemplateBody
3183   {
3184     $$ = new NamedTemplate($1, $3);
3185     $$->set_location(infile, @$);
3186   }
3187 | FieldReference AssignmentChar NotUsedSymbol
3188   {
3189     Template* temp = new Template(Template::TEMPLATE_NOTUSED);
3190     temp->set_location(infile, @3);
3191     $$ = new NamedTemplate($1, temp);
3192     $$->set_location(infile, @$);
3193   }
3194 ;
3195
3196 FieldReference: // 105
3197   StructFieldRef { $$ = $1; }
3198 /*  | ArrayOrBitRef -- covered by ArraySpecList */
3199 /*  | ParRef -- covered by StructFieldRef */
3200 ;
3201
3202 StructFieldRef: // 106 (and 107. ParRef)
3203   PredefOrIdentifier { $$ = $1; }
3204 /*  | TypeReference
3205 Note: Non-parameterized type references are covered by (StructField)Identifier.
3206       Parameterized type references are covered by FunctionInstance */
3207 | FunctionInstance
3208   {
3209     Location loc(infile, @$);
3210     loc.error("Reference to a parameterized field of type `anytype' is "
3211       "not currently supported");
3212     delete $1;
3213     $$ = new Identifier(Identifier::ID_TTCN, string("<error>"));
3214   }
3215 ;
3216
3217 ArraySpecList:
3218   '{' seqArraySpec optError '}'
3219   {
3220     $$ = new Template($2);
3221     $$->set_location(infile, @$);
3222   }
3223 ;
3224
3225 seqArraySpec:
3226   ArraySpec
3227   {
3228     $$ = new IndexedTemplates();
3229     $$->add_it($1);
3230   }
3231   /* It was optError before.  */
3232 | error ArraySpec
3233   {
3234     $$ = new IndexedTemplates();
3235     $$->add_it($2);
3236   }
3237 | seqArraySpec optError ',' optError ArraySpec
3238   {
3239     $$ = $1;
3240     $$->add_it($5);
3241   }
3242 | seqArraySpec optError ',' error { $$ = $1; }
3243 ;
3244
3245 ArraySpec:
3246   ArrayOrBitRef AssignmentChar TemplateBody
3247   {
3248     $$ = new IndexedTemplate($1, $3);
3249     $$->set_location(infile, @$);
3250   }
3251 ;
3252
3253 ArrayOrBitRef: // 109
3254   '[' Expression ']'
3255   {
3256     $$ = new FieldOrArrayRef($2);
3257     $$->set_location(infile, @$);
3258   }
3259 | '[' error ']'
3260   {
3261     $$ = new FieldOrArrayRef(new Value(Value::V_ERROR));
3262     $$->set_location(infile, @$);
3263   }
3264 ;
3265
3266 SingleValueOrAttrib: // 111
3267   MatchingSymbol { $$ = $1; }
3268 | SingleExpression
3269   {
3270     if ($1->get_valuetype() == Value::V_OMIT) {
3271       delete $1;
3272       $$ = new Template(Template::OMIT_VALUE);
3273     } else $$ = new Template($1); // SPECIFIC_VALUE; SingleExpr is a Template*
3274     $$->set_location(infile, @$);
3275   }
3276 /* | TemplateRefWithParList -- covered by SingleExpression */
3277 ;
3278
3279 ArrayValueOrAttrib: // 112
3280   '{' ArrayElementSpecList optError '}'
3281   {
3282     $$ = new Template(Template::TEMPLATE_LIST, $2);
3283     $$->set_location(infile, @$);
3284   }
3285 ;
3286
3287 ArrayElementSpecList: // 113
3288   ArrayElementSpec
3289   {
3290     $$ = new Templates;
3291     $$->add_t($1);
3292   }
3293 | error ArrayElementSpec
3294   {
3295     $$ = new Templates;
3296     $$->add_t($2);
3297   }
3298 | ArrayElementSpecList optError ',' optError ArrayElementSpec
3299   {
3300     $$=$1;
3301     $$->add_t($5);
3302   }
3303 | ArrayElementSpecList optError ',' error { $$ = $1; }
3304 ;
3305
3306 ArrayElementSpec: // 114 is a Template*
3307   NotUsedSymbol
3308   {
3309     $$ = new Template(Template::TEMPLATE_NOTUSED);
3310     $$->set_location(infile, @$);
3311   }
3312 | PermutationMatch
3313   {
3314     $$ = new Template(Template::PERMUTATION_MATCH, $1);
3315     $$->set_location(infile, @$);
3316   }
3317 | TemplateListElem { $$ = $1; }
3318 ;
3319
3320 NotUsedSymbol: // 115
3321   '-'
3322 ;
3323
3324 MatchingSymbol: // 116 is a Template*
3325   Complement
3326   {
3327     $$ = new Template(Template::COMPLEMENTED_LIST, $1);
3328     $$->set_location(infile, @$);
3329   }
3330 | AnyValue
3331   {
3332     $$ = new Template(Template::ANY_VALUE);
3333     $$->set_location(infile, @$);
3334   }
3335 | AnyOrOmit
3336   {
3337     $$ = new Template(Template::ANY_OR_OMIT);
3338     $$->set_location(infile, @$);
3339   }
3340 | ValueOrAttribList
3341   {
3342     $$ = new Template(Template::VALUE_LIST, $1);
3343     $$->set_location(infile, @$);
3344   }
3345 | Range
3346   {
3347     $$ = new Template($1);
3348     $$->set_location(infile, @$);
3349   }
3350 | BitStringMatch
3351   {
3352     $$ = new Template(Template::BSTR_PATTERN, $1);
3353     $$->set_location(infile, @$);
3354   }
3355 | HexStringMatch
3356   {
3357     $$ = new Template(Template::HSTR_PATTERN, $1);
3358     $$->set_location(infile, @$);
3359   }
3360 | OctetStringMatch
3361   {
3362     $$ = new Template(Template::OSTR_PATTERN, $1);
3363     $$->set_location(infile, @$);
3364   }
3365 | CharStringMatch
3366   {
3367     $$ = new Template($1);
3368     $$->set_location(infile, @$);
3369   }
3370 | SubsetMatch
3371   {
3372     $$ = new Template(Template::SUBSET_MATCH, $1);
3373     $$->set_location(infile, @$);
3374   }
3375 | SupersetMatch
3376   {
3377     $$ = new Template(Template::SUPERSET_MATCH, $1);
3378     $$->set_location(infile, @$);
3379   }
3380 | '(' AllElementsFrom ')'
3381   {
3382     $$ = new Template(Template::VALUE_LIST_ALL_FROM, $2);
3383     $$->set_location(infile, @$);
3384   }
3385 ;
3386
3387 optExtraMatchingAttributes: // [117]
3388   /* empty */
3389   {
3390     $$.is_ifpresent = false;
3391     $$.len_restr = NULL;
3392   }
3393 | LengthMatch
3394   {
3395     $$.len_restr = $1;
3396     $$.is_ifpresent = false;
3397   }
3398 | IfPresentMatch
3399   {
3400     $$.len_restr = NULL;
3401     $$.is_ifpresent = true;
3402   }
3403 | LengthMatch IfPresentMatch
3404   {
3405     $$.len_restr = $1;
3406     $$.is_ifpresent = true;
3407   }
3408 ;
3409
3410 CharStringMatch: // 124
3411   PatternKeyword PatternChunkList
3412   {
3413     Location loc(infile, @2);
3414     $$ = parse_pattern($2, loc);
3415     Free($2);
3416   }
3417 ;
3418
3419 PatternChunkList:
3420   PatternChunk
3421   {
3422     $$ = $1;
3423   }
3424 | PatternChunkList '&' PatternChunk
3425   {
3426     $$ = $1;
3427     $$ = mputstr($$, $3);
3428     Free($3);
3429   }
3430 ;
3431
3432 PatternChunk:
3433   Cstring
3434   {
3435     $$ = $1;
3436   }
3437 | ReferencedValue
3438   {
3439     switch ($1->get_valuetype()) {
3440     case Value::V_REFD: {
3441       /* Pretend to be a reference.  Let pstring_la.l discover the
3442          references.  */
3443       Common::Reference *ref = $1->get_reference();
3444       $$ = mprintf("{%s}", (ref->get_dispname()).c_str());
3445       break; }
3446     case Value::V_UNDEF_LOWERID: {
3447       const Common::Identifier *id = $1->get_val_id();
3448       $$ = mprintf("{%s}", (id->get_dispname()).c_str());
3449       break; }
3450     default:
3451       FATAL_ERROR("Internal error.");
3452     }
3453     /* Forget the Node.  */
3454     delete $1;
3455   }
3456 | Quadruple
3457   {
3458     ustring::universal_char& uc = $1->operator[](0);
3459     $$ = mprintf("\\q{%d,%d,%d,%d}", uc.group, uc.plane, uc.row, uc.cell);
3460     delete $1;
3461   }
3462 ;
3463
3464 Complement: // 130 is a Templates*
3465   ComplementKeyword ValueList { $$ = $2; }
3466 ;
3467
3468 ValueList: // 132 is a Templates*
3469   '(' seqValueOrAttrib optError ')' { $$ = $2; }
3470 | '(' error ')' { $$ = new Templates; }
3471 ;
3472
3473 seqValueOrAttrib: // is a Templates*
3474   optError TemplateListElem
3475   {
3476     $$ = new Templates;
3477     $$->add_t($2);
3478   }
3479 | seqValueOrAttrib optError ',' optError TemplateListElem
3480   {
3481     $$ = $1;
3482     $$->add_t($5);
3483   }
3484 | seqValueOrAttrib optError ',' error { $$ = $1; }
3485 ;
3486
3487 SubsetMatch: // 133 is a Templates*
3488   SubsetKeyword ValueList { $$ = $2; }
3489 ;
3490
3491 SupersetMatch: // 135 is a Templates*
3492   SupersetKeyword ValueList { $$ = $2; }
3493 ;
3494
3495 PermutationMatch: // 137 is a Templates*
3496   PermutationKeyword ValueList { $$ = $2; }
3497 ;
3498
3499 AnyValue: // 140
3500   '?'
3501 ;
3502
3503 AnyOrOmit: // 141
3504   '*'
3505 ;
3506
3507 TemplateListElem: // is a Template*
3508   TemplateBody
3509 | AllElementsFrom
3510 ;
3511
3512 AllElementsFrom: // is a Template*
3513   AllKeyword FromKeyword TemplateBody
3514   { // $3 is a Template*
3515     $$ = new Template($3); // Constructs ALL_FROM
3516     $$->set_location(infile, @$);
3517   }
3518 ;
3519
3520 ValueOrAttribList: // 142 is a Templates*
3521   /* ValueOrAttribList always has two or more elements
3522    * (there's always a comma) and is reduced through
3523    * ValueOrAttribList -> MatchingSymbol -> SingleValueOrAttrib
3524    *
3525    * The one-element list is reduced through
3526    * '(' SingleExpression ')' -> SingleExpression -> SingleValueOrAttrib */
3527   '(' TemplateListElem optError ',' seqValueOrAttrib optError ')'
3528   {
3529     $$ = $5;
3530     $$->add_front_t($2);
3531   }
3532 | '(' error TemplateListElem optError ',' seqValueOrAttrib optError ')'
3533   {
3534     $$ = $6;
3535     $$->add_front_t($3);
3536   }
3537 ;
3538
3539 LengthMatch: // 143
3540   StringLength { $$ = $1; }
3541 ;
3542
3543 IfPresentMatch: // 144
3544   IfPresentKeyword
3545 ;
3546
3547 Range: // 147
3548   '(' SingleLowerBound DotDot UpperBound optError ')'
3549   { $$ = new ValueRange($2, $4); }
3550 ;
3551
3552 SingleLowerBound:
3553   SingleExpression
3554   {
3555     if ($1->is_parsed_infinity()==-1) {
3556       /* the conflicting rule alternative faked here: '-' InfinityKeyword */
3557       delete $1;
3558       $$ = 0;
3559     } else {
3560       $$ = $1;
3561     }
3562   }
3563 ;
3564
3565 LowerBound: // 148
3566   Expression
3567   {
3568     if ($1->is_parsed_infinity()==-1) {
3569       /* the conflicting rule alternative faked here: '-' InfinityKeyword */
3570       delete $1;
3571       $$ = 0;
3572     } else {
3573       $$ = $1;
3574     }
3575   }
3576 ;
3577
3578 UpperBound: // 149
3579   Expression
3580   {
3581     if ($1->is_parsed_infinity()==1) {
3582       /* the conflicting rule alternative faked here: InfinityKeyword */
3583       delete $1;
3584       $$ = 0;
3585     } else {
3586       $$ = $1;
3587     }
3588   }
3589 ;
3590
3591 TemplateInstance: // 151
3592   InLineTemplate { $$ = $1; }
3593 ;
3594
3595 TemplateRefWithParList: /* refbase */ // 153 ?
3596   TemplateRef optTemplateActualParList
3597   {
3598     if ($2) {
3599       $$ = new Ttcn::Ref_pard($1.modid, $1.id, new ParsedActualParameters($2));
3600       $$->set_location(infile, @$);
3601     } else {
3602       $$ = new Ttcn::Reference($1.modid, $1.id);
3603       $$->set_location(infile, @$);
3604     }
3605   }
3606 ;
3607
3608 TemplateRef: // 154
3609   IDentifier
3610   {
3611     $$.modid = 0;
3612     $$.id = $1;
3613   }
3614 | IDentifier '.' IDentifier
3615   {
3616     $$.modid = $1;
3617     $$.id = $3;
3618   }
3619 | IDentifier '.' ObjectIdentifierValue '.' IDentifier
3620   {
3621     $$.modid = $1;
3622     $$.id = $5;
3623     delete $3;
3624   }
3625 ;
3626
3627 InLineTemplate: // 155
3628   TemplateBody
3629   {
3630     $$ = new TemplateInstance(0, 0, $1);
3631     $$->set_location(infile, @$);
3632   }
3633 | Type ':' TemplateBody
3634   {
3635     $$ = new TemplateInstance($1, 0, $3);
3636     $$->set_location(infile, @$);
3637   }
3638 /* | Signature ':' TemplateBody -- covered by the previous rule */
3639 | DerivedRefWithParList AssignmentChar TemplateBody
3640   {
3641     $$ = new TemplateInstance(0, $1, $3);
3642     $$->set_location(infile, @$);
3643   }
3644 | Type ':' DerivedRefWithParList AssignmentChar TemplateBody
3645   {
3646     $$ = new TemplateInstance($1, $3, $5);
3647     $$->set_location(infile, @$);
3648   }
3649 /* | Signature ':' DerivedRefWithParList AssignmentChar TemplateBody
3650  -- covered by the previous rule */
3651 ;
3652
3653 DerivedRefWithParList: // 156
3654   ModifiesKeyword TemplateRefWithParList { $$ = $2; }
3655 ;
3656
3657 optTemplateActualParList: // [157]
3658   /* empty */ optError { $$ = 0; }
3659 | '(' seqTemplateActualPar optError ')'
3660   {
3661     $$ = $2;
3662     $$->set_location(infile, @$);
3663   }
3664 | '(' error ')'
3665   {
3666     $$ = new TemplateInstances;
3667     $$->set_location(infile, @$);
3668   }
3669 ;
3670
3671 seqTemplateActualPar:
3672   optError TemplateActualPar
3673   {
3674     $$ = new TemplateInstances;
3675     $$->add_ti($2);
3676   }
3677 | seqTemplateActualPar optError ',' optError TemplateActualPar
3678   {
3679     $$ = $1;
3680     $$->add_ti($5);
3681   }
3682 | seqTemplateActualPar optError ',' error { $$ = $1; }
3683 ;
3684
3685 TemplateActualPar: // 158
3686   TemplateInstance { $$ = $1; }
3687 | NotUsedSymbol
3688   {
3689     Template *t = new Template(Template::TEMPLATE_NOTUSED);
3690     t->set_location(infile, @$);
3691     $$ = new TemplateInstance(0, 0, t);
3692     $$->set_location(infile, @$);
3693   }
3694 ;
3695
3696 TemplateOps: // 159
3697   MatchOp { $$ = $1; }
3698 | ValueofOp { $$ = $1; }
3699 ;
3700
3701 MatchOp: // 160
3702   MatchKeyword '(' optError Expression optError ',' optError TemplateInstance
3703   optError ')'
3704   {
3705     $$ = new Value(Value::OPTYPE_MATCH, $4, $8);
3706     $$->set_location(infile, @$);
3707   }
3708 | MatchKeyword '(' error ')'
3709   {
3710     Value *v = new Value(Value::V_ERROR);
3711     v->set_location(infile, @3);
3712     Template *t = new Template(Template::TEMPLATE_ERROR);
3713     t->set_location(infile, @3);
3714     TemplateInstance *ti = new TemplateInstance(0, 0, t);
3715     ti->set_location(infile, @3);
3716     $$ = new Value(Value::OPTYPE_MATCH, v, ti);
3717     $$->set_location(infile, @$);
3718   }
3719 ;
3720
3721 ValueofOp: // 162
3722   ValueofKeyword '(' optError TemplateInstance optError ')'
3723   {
3724     $$ = new Value(Value::OPTYPE_VALUEOF, $4);
3725     $$->set_location(infile, @$);
3726   }
3727 | ValueofKeyword '(' error ')'
3728   {
3729     Template *t = new Template(Template::TEMPLATE_ERROR);
3730     t->set_location(infile, @3);
3731     TemplateInstance *ti = new TemplateInstance(0, 0, t);
3732     ti->set_location(infile, @3);
3733     $$ = new Value(Value::OPTYPE_VALUEOF, ti);
3734     $$->set_location(infile, @$);
3735   }
3736 ;
3737
3738 /* A.1.6.1.4 Function definitions */
3739
3740 FunctionDef: // 164
3741   FunctionKeyword IDentifier '(' optFunctionFormalParList ')'
3742   optRunsOnSpec optReturnType optError StatementBlock
3743   {
3744     $4->set_location(infile, @3, @5);
3745     $$ = new Def_Function($2, $4, $6, $7.type, $7.returns_template,
3746                           $7.template_restriction, $9);
3747     $$->set_location(infile, @$);
3748   }
3749 ;
3750
3751 optFunctionFormalParList: // [167]
3752   /* empty */ { $$ = new FormalParList; }
3753 | FunctionFormalParList { $$ = $1; }
3754 | error { $$ = new FormalParList; }
3755 ;
3756
3757 FunctionFormalParList: // 167
3758   optError FunctionFormalPar
3759   {
3760     $$ = new FormalParList;
3761     $$->add_fp($2);
3762   }
3763 | FunctionFormalParList optError ',' optError FunctionFormalPar
3764   {
3765     $$ = $1;
3766     $$->add_fp($5);
3767   }
3768 | FunctionFormalParList optError ',' error { $$ = $1; }
3769 ;
3770
3771 FunctionFormalPar: // 168
3772   FormalValuePar { $$ = $1; }
3773 | FormalTimerPar { $$ = $1; }
3774 | FormalTemplatePar { $$ = $1; }
3775 /*| FormalPortPar -- covered by FormalValuePar */
3776 ;
3777
3778 optReturnType: // [169]
3779   /* empty */
3780   {
3781     $$.type = 0;
3782     $$.returns_template = false;
3783     $$.template_restriction = TR_NONE;
3784   }
3785 | ReturnKeyword Type
3786   {
3787     $$.type = $2;
3788     $$.returns_template = false;
3789     $$.template_restriction = TR_NONE;
3790   }
3791 | ReturnKeyword TemplateOptRestricted Type
3792   {
3793     $$.type = $3;
3794     $$.returns_template = true;
3795     $$.template_restriction = $2;
3796   }
3797 | ReturnKeyword error
3798   {
3799     $$.type = 0;
3800     $$.returns_template = false;
3801     $$.template_restriction = TR_NONE;
3802   }
3803 ;
3804
3805 optRunsOnComprefOrSelf:
3806   optRunsOnSpec
3807   {
3808     $$.self = false;
3809     $$.reference = $1;
3810   }
3811 | RunsKeyword OnKeyword SelfKeyword
3812   {
3813     $$.self = true;
3814     $$.reference = 0;
3815   }
3816 ;
3817
3818 optRunsOnSpec:
3819   /* empty */ { $$ = 0; }
3820 | RunsOnSpec { $$ = $1; }
3821 | RunsKeyword error { $$ = 0; }
3822 ;
3823
3824 RunsOnSpec: // 171
3825   RunsKeyword OnKeyword ComponentType { $$ = $3; }
3826 ;
3827
3828   /* StatementBlock changed in 4.1.2 to explicitly prevent statements
3829    * followed by definitions. TITAN still allows them to be mixed. */
3830 StatementBlock: /* StatementBlock *statementblock */ // 175
3831   '{' optError '}'
3832   {
3833     $$ = new StatementBlock;
3834     $$->set_location(infile, @$);
3835   }
3836 | '{' FunctionStatementOrDefList optError '}'
3837   {
3838     $$ = $2;
3839     $$->set_location(infile, @$);
3840   }
3841 ;
3842
3843 FunctionStatementOrDefList: // (171 in 3.2.1)
3844   optError FunctionStatementOrDef optSemiColon
3845   {
3846     $$ = new StatementBlock;
3847     for(size_t i=0; i<$2.nElements; i++) $$->add_stmt($2.elements[i]);
3848     Free($2.elements);
3849   }
3850 | FunctionStatementOrDefList optError FunctionStatementOrDef optSemiColon
3851   {
3852     $$=$1;
3853     for(size_t i=0; i<$3.nElements; i++) $$->add_stmt($3.elements[i]);
3854     Free($3.elements);
3855   }
3856 ;
3857
3858 FunctionStatementOrDef: // (172 in 3.2.1)
3859   FunctionLocalDef // constant or template definition
3860   {
3861     $$.nElements=$1.nElements;
3862     $$.elements=(Statement**)Malloc($$.nElements*sizeof(*$$.elements));
3863     for(size_t i=0; i<$1.nElements; i++) {
3864       $$.elements[i]=new Statement(Statement::S_DEF, $1.elements[i]);
3865       $$.elements[i]->set_location(*$1.elements[i]);
3866     }
3867     Free($1.elements);
3868   }
3869 | FunctionLocalInst // variable or timer instance
3870   {
3871     $$.nElements=$1.nElements;
3872     $$.elements=(Statement**)Malloc($$.nElements*sizeof(*$$.elements));
3873     for(size_t i=0; i<$1.nElements; i++) {
3874       $$.elements[i]=new Statement(Statement::S_DEF, $1.elements[i]);
3875       $$.elements[i]->set_location(*$1.elements[i]);
3876     }
3877     Free($1.elements);
3878   }
3879 | FunctionStatement
3880   {
3881     $$.nElements=1;
3882     $$.elements=(Statement**)Malloc($$.nElements*sizeof(*$$.elements));
3883     $$.elements[0]=$1;
3884   }
3885 ;
3886
3887 FunctionLocalInst: // 178
3888   VarInstance { $$=$1; }
3889 | TimerInstance { $$=$1; }
3890 ;
3891
3892 FunctionLocalDef: // 179
3893   ConstDef { $$=$1; }
3894 | TemplateDef
3895   {
3896     $1->set_local();
3897     $$.nElements = 1;
3898     $$.elements = (Ttcn::Definition**)Malloc(sizeof(*$$.elements));
3899     $$.elements[0] = $1;
3900   }
3901 ;
3902
3903 FunctionStatement: // 180
3904   ConfigurationStatements {$$=$1;}
3905 | TimerStatements {$$=$1;}
3906 | CommunicationStatements {$$=$1;}
3907 | BasicStatements {$$=$1;}
3908 | BehaviourStatements {$$=$1;}
3909 | VerdictStatements {$$=$1;}
3910 | SUTStatements {$$=$1;}
3911 | StopExecutionStatement { $$ = $1; }
3912 | StopTestcaseStatement { $$ = $1; }
3913 ;
3914
3915 FunctionInstance: /* refpard */ // 181
3916   FunctionRef '(' optFunctionActualParList ')'
3917   /* templateref  templinsts */
3918   {
3919     $3->set_location(infile, @2, @4);
3920     $$ = new Ttcn::Ref_pard($1.modid, $1.id, $3);
3921     $$->set_location(infile, @$);
3922   }
3923 ;
3924
3925 FunctionRef: // 182
3926   IDentifier
3927   {
3928     $$.modid = 0;
3929     $$.id = $1;
3930   }
3931   | IDentifier '.' IDentifier
3932   {
3933     $$.modid = $1;
3934     $$.id = $3;
3935   }
3936   | IDentifier '.' ObjectIdentifierValue '.' IDentifier
3937   {
3938     $$.modid = $1;
3939     $$.id = $5;
3940     delete $3;
3941   }
3942 ;
3943
3944 optFunctionActualParList: /* parsedpar */ // [185]
3945   /* empty */ optError { $$ = new ParsedActualParameters; }
3946 | FunctionActualParList optError { $$ = $1; }
3947 ;
3948
3949 /* ***** this * can * not * be * empty ****************** */
3950 FunctionActualParList: /* parsedpar */ // 184
3951   UnnamedPart
3952 | NamedPart
3953 | UnnamedPart ',' NamedPart
3954 /* Splitting the NamedPart and UnnamedPart ensures that a named parameter
3955  * followed by an unnamed one causes a syntax error */
3956 {
3957     /* UnnamedPart becomes the value */
3958     $$ = $1;
3959     /* append the elements from NamedPart */
3960     const size_t n3 = $3->get_nof_nps();
3961     for (size_t i = 0; i < n3; ++i) {
3962         $$->add_np( $3->extract_np_byIndex(i) );
3963     }
3964     delete $3;
3965 }
3966 ;
3967
3968 UnnamedPart: /* parsedpar */
3969 /*optError*/ FunctionActualPar
3970 {
3971   $$ = new ParsedActualParameters;
3972   $$->add_ti($1);
3973 }
3974 | UnnamedPart /*optError*/ ',' /*optError*/ FunctionActualPar
3975 /* These optErrors mess up the parsing of actual parameters.
3976  * After only one FunctionActualPar, it is reduced to UnnamedPart
3977  * and the rest is expected to be the NamedPart */
3978 {
3979   $$ = $1;
3980   $$->add_ti($3);
3981 }
3982 | UnnamedPart optError ',' error { $$ = $1; }
3983 ;
3984
3985 NamedPart: /* parsedpar */
3986   seqFieldSpec /* namedtempls */
3987   {
3988     $$ = new ParsedActualParameters(0, new NamedParams);
3989     const size_t n1 = $1->get_nof_nts();
3990     for (size_t i = 0; i < n1; ++i) {
3991         NamedTemplate *pnt = $1->get_nt_byIndex(i);
3992         TemplateInstance *pti = new TemplateInstance(0,0,pnt->extract_template());
3993         NamedParam *pnp = new NamedParam(pnt->get_name().clone(), pti);
3994         pnp->set_location(*pnt);
3995         $$->add_np(pnp);
3996     }
3997     delete $1;
3998     $$->set_location(infile, @$);
3999     // This call to ParsedActualParameters::set_location copies the same
4000     // location info to the named and unnamed part. We cannot copy
4001     // the location info from the NamedTemplates to the named part,
4002     // because NamedTemplates is not a Location.
4003   }
4004 ;
4005
4006 FunctionActualPar: /* templinst */ // 185
4007 /*  TimerRef */
4008   TemplateInstance { $$ = $1; }
4009 | NotUsedSymbol
4010   {
4011     Template *t = new Template(Template::TEMPLATE_NOTUSED);
4012     t->set_location(infile, @$);
4013     $$ = new TemplateInstance(0, 0, t);
4014     $$->set_location(infile, @$);
4015   }
4016 /* | Port
4017    | ComponentRef -- TemplateInstance covers all the others */
4018 ;
4019
4020 ApplyOp:
4021   Reference DotApplyKeyword '(' optFunctionActualParList ')'
4022   {
4023     if($1.is_ref) $$.value = new Value(Value::V_REFD, $1.ref);
4024     else {
4025       Ttcn::Reference *t_ref = new Ttcn::Reference($1.id);
4026       t_ref->set_location(infile, @1);
4027       $$.value = new Value(Value::V_REFD, t_ref);
4028     }
4029     $$.value->set_location(infile, @1);
4030     $$.ap_list = $4;
4031     $$.ap_list->set_location(infile, @3 , @5);
4032   }
4033   | FunctionInstance DotApplyKeyword '(' optFunctionActualParList ')'
4034   {
4035     $$.value = new Value(Value::V_REFD, $1);
4036     $$.value->set_location(infile, @1);
4037     $$.ap_list = $4;
4038     $$.ap_list->set_location(infile, @3 , @5);
4039   }
4040   | ApplyOp DotApplyKeyword '(' optFunctionActualParList ')'
4041   {
4042     $$.value = new Value(Value::V_INVOKE, $1.value, $1.ap_list);
4043     $$.value->set_location(infile, @1);
4044     $$.ap_list = $4;
4045     $$.ap_list->set_location(infile, @3 , @5);
4046   }
4047 ;
4048
4049 DereferOp:
4050   DerefersKeyword '(' Expression ')' { $$ = $3; }
4051 ;
4052
4053 /* A.1.6.1.5 Signature definitions */
4054
4055 SignatureDef: // 187
4056   SignatureKeyword IDentifier
4057   '(' optSignatureFormalParList ')' optReturnTypeOrNoBlockKeyword
4058   optExceptionSpec
4059   {
4060     Type *type = new Type(Type::T_SIGNATURE, $4, $6.type, $6.no_block_kw, $7);
4061     type->set_location(infile, @3, @7);
4062     $$ = new Ttcn::Def_Type($2, type);
4063     $$->set_location(infile, @$);
4064   }
4065 ;
4066
4067 optSignatureFormalParList: // [190]
4068   /* empty */ { $$ = 0; }
4069 | SignatureFormalParList { $$ = $1; }
4070 | error { $$ = 0; }
4071 ;
4072
4073 SignatureFormalParList: // 190
4074   optError SignatureFormalPar
4075   {
4076     $$ = new SignatureParamList;
4077     $$->add_param($2);
4078   }
4079 | SignatureFormalParList optError ',' optError SignatureFormalPar
4080   {
4081     $$ = $1;
4082     $$->add_param($5);
4083   }
4084 | SignatureFormalParList optError ',' error { $$ = $1; }
4085 ;
4086
4087 SignatureFormalPar: // 191
4088   Type IDentifier
4089   {
4090     $$ = new SignatureParam(SignatureParam::PARAM_IN, $1, $2);
4091     $$->set_location(infile, @$);
4092   }
4093 | InParKeyword Type IDentifier
4094   {
4095     $$ = new SignatureParam(SignatureParam::PARAM_IN, $2, $3);
4096     $$->set_location(infile, @$);
4097   }
4098 | InOutParKeyword Type IDentifier
4099   {
4100     $$ = new SignatureParam(SignatureParam::PARAM_INOUT, $2, $3);
4101     $$->set_location(infile, @$);
4102   }
4103 | OutParKeyword Type IDentifier
4104   {
4105     $$ = new SignatureParam(SignatureParam::PARAM_OUT, $2, $3);
4106     $$->set_location(infile, @$);
4107   }
4108 ;
4109
4110 optReturnTypeOrNoBlockKeyword:
4111   /* empty */
4112   {
4113     $$.type = NULL;
4114     $$.no_block_kw = false;
4115   }
4116 | ReturnKeyword Type
4117   {
4118     $$.type = $2;
4119     $$.no_block_kw = false;
4120   }
4121 | NoBlockKeyword
4122   {
4123     $$.type = NULL;
4124     $$.no_block_kw = true;
4125   }
4126 ;
4127
4128 optExceptionSpec: // [192]
4129   /* empty */ { $$ = NULL; }
4130 | ExceptionKeyword '(' error ')' { $$ = NULL; }
4131 | ExceptionKeyword '(' ExceptionTypeList optError ')'
4132   {
4133     $$ = $3;
4134     $$->set_location(infile, @$);
4135   }
4136 ;
4137
4138 ExceptionTypeList: // 194
4139   optError Type
4140   {
4141     $$ = new SignatureExceptions;
4142     $$->add_type($2);
4143   }
4144 | ExceptionTypeList optError ',' optError Type
4145   {
4146     $$ = $1;
4147     $$->add_type($5);
4148   }
4149 | ExceptionTypeList optError ',' error { $$ = $1; }
4150 ;
4151
4152 Signature: // 196
4153   IDentifier
4154   {
4155     $$ = new Ttcn::Reference($1);
4156     $$->set_location(infile, @$);
4157   }
4158 | IDentifier '.' IDentifier
4159   {
4160     $$ = new Ttcn::Reference($1, $3);
4161     $$->set_location(infile, @$);
4162   }
4163 | IDentifier '.' ObjectIdentifierValue '.' IDentifier
4164   {
4165     $$ = new Ttcn::Reference($1, $5);
4166     $$->set_location(infile, @$);
4167     delete $3;
4168   }
4169 ;
4170
4171 /* A.1.6.1.6 Testcase definitions */
4172
4173 TestcaseDef: // 197
4174   TestcaseKeyword IDentifier '(' optTestcaseFormalParList ')'
4175   ConfigSpec optError StatementBlock
4176   {
4177     $4->set_location(infile, @3, @5);
4178     $$ = new Def_Testcase($2, $4, $6.runsonref, $6.systemref, $8);
4179     $$->set_location(infile, @$);
4180   }
4181 ;
4182
4183 optTestcaseFormalParList: // [200]
4184   /* empty */ { $$ = new FormalParList; }
4185 | TestcaseFormalParList { $$ = $1; }
4186 | error { $$ = new FormalParList; }
4187 ;
4188
4189 TestcaseFormalParList: // 200
4190   optError TestcaseFormalPar
4191   {
4192     $$ = new FormalParList;
4193     $$->add_fp($2);
4194   }
4195 | TestcaseFormalParList optError ',' optError TestcaseFormalPar
4196   {
4197     $$ = $1;
4198     $$->add_fp($5);
4199   }
4200 | TestcaseFormalParList optError ',' error { $$ = $1; }
4201 ;
4202
4203 TestcaseFormalPar: // 201
4204   FormalValuePar { $$ = $1; }
4205 | FormalTemplatePar { $$ = $1; }
4206 ;
4207
4208 ConfigSpec: // 202
4209   RunsOnSpec optSystemSpec
4210   {
4211     $$.runsonref=$1;
4212     $$.systemref=$2;
4213   }
4214 ;
4215
4216 optSystemSpec: // [203]
4217   /* empty */ { $$ = 0; }
4218 | SystemKeyword ComponentType { $$ = $2; }
4219 | SystemKeyword error { $$ = 0; }
4220 ;
4221
4222 TestcaseInstance: // 205
4223   ExecuteKeyword '(' TestcaseRef '(' optTestcaseActualParList ')'
4224   optTestcaseTimerValue optError ')'
4225   {
4226     $5->set_location(infile, @4, @6);
4227     $$.ref_pard = new Ttcn::Ref_pard($3.modid, $3.id, $5);
4228     $$.ref_pard->set_location(infile, @3, @6);
4229     $$.derefered_value = 0;
4230     $$.ap_list = $5;
4231     $$.value = $7;
4232   }
4233 | ExecuteKeyword '(' DereferOp '(' optTestcaseActualParList ')'
4234   optTestcaseTimerValue optError ')'
4235   {
4236     $5->set_location(infile, @4, @6);
4237     $$.ref_pard = 0;
4238     $$.derefered_value = $3;
4239     $$.ap_list = $5;
4240     $$.value = $7;
4241   }
4242 | ExecuteKeyword '(' error ')'
4243   {
4244     $$.ref_pard = 0;
4245     $$.derefered_value = 0;
4246     $$.ap_list = 0;
4247     $$.value = 0;
4248   }
4249 ;
4250
4251 TestcaseRef: // 207
4252   IDentifier
4253   {
4254     $$.modid = NULL;
4255     $$.id = $1;
4256   }
4257 | IDentifier '.' IDentifier
4258   {
4259     $$.modid = $1;
4260     $$.id = $3;
4261   }
4262 | IDentifier '.' ObjectIdentifierValue '.' IDentifier
4263   {
4264     $$.modid = $1;
4265     $$.id = $5;
4266     delete $3;
4267   }
4268 ;
4269
4270 optTestcaseTimerValue:
4271   /* empty */ { $$ = 0; }
4272 | ',' optError Expression { $$ = $3; }
4273 | ',' error
4274   {
4275     $$ = new Value(Value::V_ERROR);
4276     $$->set_location(infile, @$);
4277   }
4278 ;
4279
4280 optTestcaseActualParList: // [202]
4281   /* empty */ optError { $$ = new ParsedActualParameters; }
4282 | TestcaseActualParList optError { $$ = $1; }
4283 ;
4284
4285 TestcaseActualParList: // 208
4286 UnnamedPart
4287 | NamedPart
4288 | UnnamedPart ',' NamedPart
4289 /* Splitting the NamedPart and UnnamedPart ensures that a named parameter
4290 * followed by an unnamed one causes a syntax error */
4291 {
4292   /* UnnamedPart becomes the value */
4293   $$ = $1;
4294   /* append the elements from NamedPart */
4295   const size_t n3 = $3->get_nof_nps();
4296   for (size_t i = 0; i < n3; ++i) {
4297         $$->add_np( $3->extract_np_byIndex(i) );
4298   }
4299   delete $3;
4300 }
4301
4302 /*
4303   optError TestcaseActualPar
4304   {
4305     $$ = new TemplateInstances;
4306     $$->add_ti($2);
4307   }
4308 | TestcaseActualParList optError ',' optError TestcaseActualPar
4309   {
4310     $$ = $1;
4311     $$->add_ti($5);
4312   }
4313 | TestcaseActualParList optError ',' error { $$ = $1; }
4314 */
4315 ;
4316
4317 /*
4318 TestcaseActualPar:
4319   TemplateInstance { $$ = $1; }
4320 | NotUsedSymbol
4321   {
4322     Template *t = new Template(Template::TEMPLATE_NOTUSED);
4323     t->set_location(infile, @$);
4324     $$ = new TemplateInstance(0, 0, t);
4325     $$->set_location(infile, @$);
4326   }
4327 ;
4328 */
4329
4330 /* A.1.6.1.7 Altstep definitions */
4331
4332 AltstepDef: // 211
4333   AltstepKeyword IDentifier '(' optAltstepFormalParList ')' optRunsOnSpec
4334   optError '{' AltstepLocalDefList AltGuardList optError '}'
4335   {
4336     StatementBlock *sb = new StatementBlock;
4337     for (size_t i = 0; i < $9.nElements; i++) {
4338       Statement *stmt = new Statement(Statement::S_DEF, $9.elements[i]);
4339       stmt->set_location(*$9.elements[i]);
4340       sb->add_stmt(stmt);
4341     }
4342     Free($9.elements);
4343     $4->set_location(infile, @4);
4344     $$ = new Def_Altstep($2, $4, $6, sb, $10);
4345     $$->set_location(infile, @$);
4346   }
4347 ;
4348
4349 optAltstepFormalParList: // [214]
4350   /* empty */ { $$ = new FormalParList; }
4351 | FunctionFormalParList { $$ = $1; }
4352 | error { $$ = new FormalParList; }
4353 ;
4354
4355 AltstepLocalDefList: // 215
4356   /* empty */
4357   {
4358     $$.nElements = 0;
4359     $$.elements = 0;
4360   }
4361 | AltstepLocalDefList optError AltstepLocalDef optSemiColon
4362   {
4363     $$.nElements = $1.nElements + $3.nElements;
4364     $$.elements = (Ttcn::Definition**)
4365       Realloc($1.elements, $$.nElements * sizeof(*$$.elements));
4366     memcpy($$.elements + $1.nElements, $3.elements,
4367            $3.nElements * sizeof(*$$.elements));
4368     Free($3.elements);
4369   }
4370 ;
4371
4372 AltstepLocalDef: // 216
4373   VarInstance { $$ = $1; }
4374 | TimerInstance { $$ = $1; }
4375 | ConstDef { $$ = $1; }
4376 | TemplateDef
4377   {
4378     $1->set_local();
4379     $$.nElements = 1;
4380     $$.elements = (Ttcn::Definition**)Malloc(sizeof(*$$.elements));
4381     $$.elements[0] = $1;
4382   }
4383 ;
4384
4385 AltstepInstance: /* refpard */ // 217
4386   FunctionRef '(' optFunctionActualParList ')'
4387   {
4388     $3->set_location(infile, @2, @4);
4389     $$ = new Ttcn::Ref_pard($1.modid, $1.id, $3);
4390     $$->set_location(infile, @$);
4391   }
4392 ;
4393
4394 /* Taken over by FunctionRef
4395 AltstepRef: // 211
4396   IDentifier
4397 | IDentifier '.' IDentifier
4398 | IDentifier '.' ObjectIdentifierValue '.' IDentifier
4399 ;
4400 */
4401
4402 /* A.1.6.1.8 Import definitions */
4403
4404 ImportDef: // 219
4405   ImportKeyword ImportFromSpec AllWithExcepts
4406   {
4407     $2->set_imptype(ImpMod::I_ALL);
4408     $2->set_location(infile, @$);
4409
4410     $$ = $2;
4411   }
4412 | ImportKeyword ImportFromSpec '{' ImportSpec '}'
4413   {
4414     Location loc(infile, @$);
4415     if ( $4 == ImpMod::I_IMPORTSPEC) {
4416       loc.warning("Unsupported selective import statement was treated as "
4417                 "`import all'");
4418     }
4419     $2->set_imptype($4);
4420     $2->set_location(infile, @$);
4421
4422     $$ = $2;
4423   }
4424 ;
4425
4426 AllWithExcepts: // 221
4427   AllKeyword
4428 | AllKeyword ExceptsDef
4429   {
4430     Location loc(infile, @$);
4431     loc.warning("Unsupported selective import statement was treated as "
4432                 "`import all'");
4433   }
4434 ;
4435
4436 ExceptsDef: // 222
4437   ExceptKeyword '{' ExceptSpec '}'
4438 ;
4439
4440 ExceptSpec: // 224
4441   /* empty */ optError
4442 | ExceptSpec ExceptElement optSemiColon
4443 ;
4444
4445 ExceptElement: // 225
4446   ExceptGroupSpec
4447 | ExceptTypeDefSpec
4448 | ExceptTemplateSpec
4449 | ExceptConstSpec
4450 | ExceptTestcaseSpec
4451 | ExceptAltstepSpec
4452 | ExceptFunctionSpec
4453 | ExceptSignatureSpec
4454 | ExceptModuleParSpec
4455 ;
4456
4457 ExceptGroupSpec: // 226
4458   GroupKeyword ExceptGroupRefList
4459 | GroupKeyword AllKeyword
4460 ;
4461
4462 ExceptTypeDefSpec: // 227
4463   TypeDefKeyword TypeRefList
4464 | TypeDefKeyword AllKeyword
4465 ;
4466
4467 ExceptTemplateSpec: // 228
4468   TemplateKeyword TemplateRefList
4469 | TemplateKeyword AllKeyword
4470 ;
4471
4472 ExceptConstSpec: // 229
4473   ConstKeyword ConstRefList
4474 | ConstKeyword AllKeyword
4475 ;
4476
4477 ExceptTestcaseSpec: // 230
4478   TestcaseKeyword TestcaseRefList
4479 | TestcaseKeyword AllKeyword
4480 ;
4481
4482 ExceptAltstepSpec: // 231
4483   AltstepKeyword AltstepRefList
4484 | AltstepKeyword AllKeyword
4485 ;
4486
4487 ExceptFunctionSpec: // 232
4488   FunctionKeyword FunctionRefList
4489 | FunctionKeyword AllKeyword
4490 ;
4491
4492 ExceptSignatureSpec: // 233
4493   SignatureKeyword SignatureRefList
4494 | SignatureKeyword AllKeyword
4495 ;
4496
4497 ExceptModuleParSpec: // 234
4498   ModuleParKeyword ModuleParRefList
4499 | ModuleParKeyword AllKeyword
4500 ;
4501
4502 ImportSpec: // 235
4503   /* empty */ optError
4504   { $$ = ImpMod::I_ALL; }
4505   | ImportSpec ImportElement optSemiColon
4506   {
4507     switch ($$) {
4508     case ImpMod::I_ALL: // it was empty before
4509       $$ = $2;
4510       break;
4511
4512     case ImpMod::I_IMPORTSPEC:
4513       switch ($2) {
4514       case ImpMod::I_IMPORTSPEC:
4515         // selective import followed by another selective import: NOP
4516         break;
4517       case ImpMod::I_IMPORTIMPORT:
4518         $$ = $2; // import of import wins over selective import
4519         break;
4520       default: // including I_ALL
4521         FATAL_ERROR("Selective import cannot be followed by import all");
4522       }
4523       break;
4524
4525     case ImpMod::I_IMPORTIMPORT:
4526       switch ($2) {
4527       case ImpMod::I_IMPORTSPEC:
4528         // import of import followed by selective import: NOP (import of import wins)
4529         break;
4530       case ImpMod::I_IMPORTIMPORT:
4531         // import of import following another import of import: error
4532         Location(infile, @2).error("Import of imports can only be used once");
4533         break;
4534       default: // including I_ALL
4535         FATAL_ERROR("Import of imports cannot be followed by import all");
4536       }
4537       break;
4538
4539     default:
4540       FATAL_ERROR("Invalid import type");
4541     }
4542   }
4543 ;
4544
4545 ImportElement: // 236
4546   ImportGroupSpec
4547   { $$ = ImpMod::I_IMPORTSPEC; }
4548 | ImportTypeDefSpec
4549   { $$ = ImpMod::I_IMPORTSPEC; }
4550 | ImportTemplateSpec
4551   { $$ = ImpMod::I_IMPORTSPEC; }
4552 | ImportConstSpec
4553   { $$ = ImpMod::I_IMPORTSPEC; }
4554 | ImportTestcaseSpec
4555   { $$ = ImpMod::I_IMPORTSPEC; }
4556 | ImportAltstepSpec
4557   { $$ = ImpMod::I_IMPORTSPEC; }
4558 | ImportFunctionSpec
4559   { $$ = ImpMod::I_IMPORTSPEC; }
4560 | ImportSignatureSpec
4561   { $$ = ImpMod::I_IMPORTSPEC; }
4562 | ImportModuleParSpec
4563   { $$ = ImpMod::I_IMPORTSPEC; }
4564 | ImportImportSpec
4565   { $$ = ImpMod::I_IMPORTIMPORT; }
4566 ;
4567
4568 ImportImportSpec:
4569   ImportKeyword AllKeyword
4570
4571 ImportFromSpec: // 237
4572   FromKeyword ModuleId { $$ = $2; }
4573 | FromKeyword ModuleId RecursiveKeyword // already deprecated in v3.2.1
4574   {
4575     $$ = $2;
4576     $$->set_recursive();
4577   }
4578 ;
4579
4580 ImportGroupSpec: // 239
4581   GroupKeyword GroupRefListWithExcept
4582 | GroupKeyword AllGroupsWithExcept
4583 | GroupKeyword error
4584 ;
4585
4586 GroupRefList: // 240
4587   optError FullGroupIdentifier { delete $2; }
4588 | GroupRefList optError ',' optError FullGroupIdentifier { delete $5; }
4589 | GroupRefList optError ',' error
4590 ;
4591
4592 GroupRefListWithExcept: // 241
4593   optError FullGroupIdentifierWithExcept
4594 | GroupRefListWithExcept optError ',' optError FullGroupIdentifierWithExcept
4595 | GroupRefListWithExcept optError ',' error
4596 ;
4597
4598 AllGroupsWithExcept: // 242
4599   AllKeyword
4600 | AllKeyword error
4601 | AllKeyword ExceptKeyword GroupRefList
4602 | AllKeyword ExceptKeyword error
4603 ;
4604
4605 FullGroupIdentifier: // 243
4606   IDentifier
4607   {
4608     $$ = new Qualifier();
4609     $$->add(new FieldOrArrayRef($1));
4610     $$->set_location(infile, @$);
4611   }
4612 | FullGroupIdentifier '.' IDentifier
4613   {
4614     $$ = $1;
4615     $$->add(new FieldOrArrayRef($3));
4616     $$->set_location(infile, @$);
4617   }
4618 ;
4619
4620 FullGroupIdentifierWithExcept: // 244
4621   FullGroupIdentifier { delete $1; }
4622 | FullGroupIdentifier ExceptsDef { delete $1; }
4623 ;
4624
4625 ExceptGroupRefList: // 245
4626   optError ExceptFullGroupIdentifier
4627 | ExceptGroupRefList optError ',' optError ExceptFullGroupIdentifier
4628 | ExceptGroupRefList optError ',' error
4629 ;
4630
4631 ExceptFullGroupIdentifier: // 246
4632   FullGroupIdentifier { delete $1;}
4633 ;
4634
4635 ImportTypeDefSpec: // 247
4636   TypeDefKeyword TypeRefList
4637 | TypeDefKeyword AllTypesWithExcept
4638 | TypeDefKeyword error
4639 ;
4640
4641 TypeRefList: // 248
4642   optError IDentifier { delete $2; }
4643 | TypeRefList optError ',' optError IDentifier { delete $5; }
4644 | TypeRefList optError ',' error
4645 ;
4646
4647 AllTypesWithExcept: // 249
4648   AllKeyword
4649 | AllKeyword error
4650 | AllKeyword ExceptKeyword TypeRefList
4651 | AllKeyword ExceptKeyword error
4652 ;
4653
4654 /* 250. TypeDefIdentifier is replaced by IDentifier */
4655
4656 ImportTemplateSpec: // 251
4657   TemplateKeyword TemplateRefList
4658 | TemplateKeyword AllTemplsWithExcept
4659 | TemplateKeyword error
4660 ;
4661
4662 TemplateRefList: // 252
4663   optError IDentifier { delete $2; }
4664 | TemplateRefList optError ',' optError IDentifier { delete $5; }
4665 | TemplateRefList optError ',' error
4666 ;
4667
4668 AllTemplsWithExcept: // 253
4669   AllKeyword
4670 | AllKeyword error
4671 | AllKeyword ExceptKeyword TemplateRefList
4672 | AllKeyword ExceptKeyword error
4673 ;
4674
4675 ImportConstSpec: // 254
4676   ConstKeyword ConstRefList
4677 | ConstKeyword AllConstsWithExcept
4678 | ConstKeyword error
4679 ;
4680
4681 ConstRefList: // 255
4682   optError IDentifier { delete $2; }
4683 | ConstRefList optError ',' optError IDentifier { delete $5; }
4684 | ConstRefList optError ',' error
4685 ;
4686
4687 AllConstsWithExcept: // 256
4688   AllKeyword
4689 | AllKeyword error
4690 | AllKeyword ExceptKeyword ConstRefList
4691 | AllKeyword ExceptKeyword error
4692 ;
4693
4694 ImportAltstepSpec: // 257
4695   AltstepKeyword AltstepRefList
4696 | AltstepKeyword AllAltstepsWithExcept
4697 | AltstepKeyword error
4698 ;
4699
4700 AltstepRefList: // 258
4701   optError IDentifier { delete $2; }
4702 | AltstepRefList optError ',' optError IDentifier { delete $5; }
4703 | AltstepRefList optError ',' error
4704 ;
4705
4706 AllAltstepsWithExcept: // 259
4707   AllKeyword
4708 | AllKeyword error
4709 | AllKeyword ExceptKeyword AltstepRefList
4710 | AllKeyword ExceptKeyword error
4711 ;
4712
4713 ImportTestcaseSpec: // 260
4714   TestcaseKeyword TestcaseRefList
4715 | TestcaseKeyword AllTestcasesWithExcept
4716 | TestcaseKeyword error
4717 ;
4718
4719 TestcaseRefList: // 261
4720   optError IDentifier { delete $2; }
4721 | TestcaseRefList optError ',' optError IDentifier { delete $5; }
4722 | TestcaseRefList optError ',' error
4723 ;
4724
4725 AllTestcasesWithExcept: // 262
4726   AllKeyword
4727 | AllKeyword error
4728 | AllKeyword ExceptKeyword TestcaseRefList
4729 | AllKeyword ExceptKeyword error
4730 ;
4731
4732 ImportFunctionSpec: // 263
4733   FunctionKeyword FunctionRefList
4734 | FunctionKeyword AllFunctionsWithExcept
4735 | FunctionKeyword error
4736 ;
4737
4738 FunctionRefList: // 264
4739   optError IDentifier { delete $2; }
4740 | FunctionRefList optError ',' optError IDentifier { delete $5; }
4741 | FunctionRefList optError ',' error
4742 ;
4743
4744 AllFunctionsWithExcept: // 265
4745   AllKeyword
4746 | AllKeyword error
4747 | AllKeyword ExceptKeyword FunctionRefList
4748 | AllKeyword ExceptKeyword error
4749 ;
4750
4751 ImportSignatureSpec: // 266
4752   SignatureKeyword SignatureRefList
4753 | SignatureKeyword AllSignaturesWithExcept
4754 | SignatureKeyword error
4755 ;
4756
4757 SignatureRefList: // 267
4758   optError IDentifier { delete $2; }
4759 | SignatureRefList optError ',' optError IDentifier { delete $5; }
4760 | SignatureRefList optError ',' error
4761 ;
4762
4763 AllSignaturesWithExcept: // 268
4764   AllKeyword
4765 | AllKeyword error
4766 | AllKeyword ExceptKeyword SignatureRefList
4767 | AllKeyword ExceptKeyword error
4768 ;
4769
4770 ImportModuleParSpec: // 269
4771   ModuleParKeyword ModuleParRefList
4772 | ModuleParKeyword AllModuleParWithExcept
4773 | ModuleParKeyword error
4774 ;
4775
4776 ModuleParRefList: // 270
4777   optError IDentifier { delete $2; }
4778 | ModuleParRefList optError ',' optError IDentifier { delete $5; }
4779 | ModuleParRefList optError ',' error
4780 ;
4781
4782 AllModuleParWithExcept: // 271
4783   AllKeyword
4784 | AllKeyword error
4785 | AllKeyword ExceptKeyword ModuleParRefList
4786 | AllKeyword ExceptKeyword error
4787 ;
4788
4789 // 272 ImportImportSpec: ImportKeyword AllKeyword
4790
4791 /* A.1.6.1.9 Group definitions */
4792
4793 GroupDef: // 273
4794   GroupIdentifier '{' optErrorBlock '}'
4795   {
4796     $$ = $1;
4797     $$->set_location(infile, @$);
4798   }
4799 | GroupIdentifier '{' ModuleDefinitionsList optErrorBlock '}'
4800   {
4801     $$ = $1;
4802     $$->set_location(infile, @$);
4803   }
4804 ;
4805
4806 GroupIdentifier: // 274 (followed by) 275.
4807   GroupKeyword IDentifier
4808   {
4809     $$ = new Group($2);
4810     $$->set_parent_group(act_group);
4811     $$->set_location(infile, @$);
4812     if (act_group) {
4813       act_group->add_group($$);
4814       $$->set_parent_path(act_group->get_attrib_path());
4815     } else {
4816       act_ttcn3_module->add_group($$);
4817       $$->set_parent_path(act_ttcn3_module->get_attrib_path());
4818     }
4819     act_group = $$;
4820   }
4821 ;
4822
4823 /* A.1.6.1.10 External function definitions */
4824
4825 ExtFunctionDef: // 276
4826   ExtKeyword FunctionKeyword IDentifier
4827   '(' optFunctionFormalParList ')' optReturnType
4828   {
4829     $5->set_location(infile, @4, @6);
4830     $$ = new Def_ExtFunction($3, $5, $7.type, $7.returns_template,
4831                              $7.template_restriction);
4832     $$->set_location(infile, @$);
4833   }
4834 ;
4835
4836 /* A.1.6.1.11 External constant definitions */
4837
4838 ExtConstDef: // 279
4839   ExtKeyword ConstKeyword Type IdentifierList
4840   {
4841     $$.nElements = $4.nElements;
4842     $$.elements = (Ttcn::Definition**)
4843       Malloc($$.nElements * sizeof(*$$.elements));
4844     for (size_t i = 0; i < $$.nElements; i++) {
4845       Type *type;
4846       if (i > 0) {
4847         type = new Type(Type::T_REFDSPEC, $3);
4848         type->set_location(*$3);
4849       } else type = $3;
4850       $$.elements[i] = new Ttcn::Def_ExtConst($4.elements[i].id, type);
4851       $$.elements[i]->set_location(infile, $4.elements[i].yyloc);
4852     }
4853     Free($4.elements);
4854   }
4855 ;
4856
4857 IdentifierList: // 280 ExtConstIdentifierList
4858   optError IDentifier
4859   {
4860     $$.nElements = 1;
4861     $$.elements = (YYSTYPE::extconstidentifier_t*)Malloc(sizeof(*$$.elements));
4862     $$.elements[0].id = $2;
4863     $$.elements[0].yyloc = @2;
4864   }
4865 | IdentifierList ',' optError IDentifier
4866   {
4867     $$.nElements = $1.nElements + 1;
4868     $$.elements = (YYSTYPE::extconstidentifier_t*)
4869       Realloc($1.elements, $$.nElements * sizeof(*$$.elements));
4870     $$.elements[$1.nElements].id = $4;
4871     $$.elements[$1.nElements].yyloc = @4;
4872   }
4873 | IdentifierList ',' error { $$ = $1; }
4874 ;
4875
4876 /* A.1.6.1.12 Module parameter definitions */
4877
4878 ModuleParDef: // 282
4879   ModuleParKeyword ModulePar { $$ = $2; }
4880 | ModuleParKeyword '{' MultiTypedModuleParList optError '}' { $$ = $3; }
4881 | ModuleParKeyword '{' error '}' { $$.nElements = 0; $$.elements = NULL; }
4882 ;
4883
4884 MultiTypedModuleParList: // 284
4885   optError ModulePar optSemiColon { $$ = $2; }
4886 | MultiTypedModuleParList optError ModulePar optSemiColon
4887   {
4888     $$.nElements = $1.nElements + $3.nElements;
4889     $$.elements = (Ttcn::Definition**)
4890           Realloc($1.elements, $$.nElements * sizeof(*$$.elements));
4891     memcpy($$.elements + $1.nElements, $3.elements,
4892       $3.nElements * sizeof(*$$.elements));
4893     Free($3.elements);
4894   }
4895 ;
4896
4897 ModulePar: // 285
4898   Type ModuleParList
4899   {
4900     $$.nElements = $2.nElements;
4901     $$.elements = (Ttcn::Definition**)
4902       Malloc($$.nElements * sizeof(*$$.elements));
4903     for(size_t i = 0; i < $2.nElements; i++) {
4904       Type *type;
4905       if (i > 0) {
4906         type = new Type(Type::T_REFDSPEC, $1);
4907         type->set_location(*$1);
4908       } else type = $1;
4909       $$.elements[i] = new Def_Modulepar($2.elements[i].id, type,
4910         $2.elements[i].defval);
4911       $$.elements[i]->set_location(infile, $2.elements[i].yyloc);
4912     }
4913     Free($2.elements);
4914   }
4915 | TemplateKeyword Type TemplateModuleParList
4916   {
4917     $$.nElements = $3.nElements;
4918     $$.elements = (Ttcn::Definition**)Malloc($$.nElements * sizeof(*$$.elements));
4919     for(size_t i = 0; i < $3.nElements; i++) {
4920       Type *type;
4921       if (i > 0) {
4922         type = new Type(Type::T_REFDSPEC, $2);
4923         type->set_location(*$2);
4924       } else type = $2;
4925       $$.elements[i] = new Def_Modulepar_Template($3.elements[i].id, type, $3.elements[i].deftempl);
4926       $$.elements[i]->set_location(infile, $3.elements[i].yyloc);
4927     }
4928     Free($3.elements);
4929   }
4930 ;
4931
4932 ModuleParList: // 287
4933   optError SingleModulePar
4934   {
4935     $$.nElements = 1;
4936     $$.elements = (YYSTYPE::singlemodulepar_t*)Malloc(sizeof(*$$.elements));
4937     $$.elements[0] = $2;
4938   }
4939 | ModuleParList ',' optError SingleModulePar
4940   {
4941     $$.nElements = $1.nElements + 1;
4942     $$.elements = (YYSTYPE::singlemodulepar_t*)
4943       Realloc($1.elements, $$.nElements * sizeof(*$$.elements));
4944     $$.elements[$$.nElements - 1] = $4;
4945   }
4946 ;
4947
4948 TemplateModuleParList: // 287
4949   optError SingleTemplateModulePar
4950   {
4951     $$.nElements = 1;
4952     $$.elements = (YYSTYPE::singletemplatemodulepar_t*)Malloc(sizeof(*$$.elements));
4953     $$.elements[0] = $2;
4954   }
4955 | TemplateModuleParList ',' optError SingleTemplateModulePar
4956   {
4957     $$.nElements = $1.nElements + 1;
4958     $$.elements = (YYSTYPE::singletemplatemodulepar_t*)
4959       Realloc($1.elements, $$.nElements * sizeof(*$$.elements));
4960     $$.elements[$$.nElements - 1] = $4;
4961   }
4962 ;
4963
4964 SingleModulePar:
4965   IDentifier
4966   {
4967     $$.id = $1;
4968     $$.defval = NULL;
4969     $$.yyloc = @$;
4970   }
4971 | IDentifier AssignmentChar Expression
4972   {
4973     $$.id = $1;
4974     $$.defval = $3;
4975     $$.yyloc = @$;
4976   }
4977 ;
4978
4979 SingleTemplateModulePar:
4980   IDentifier
4981   {
4982     $$.id = $1;
4983     $$.deftempl = NULL;
4984     $$.yyloc = @$;
4985   }
4986 | IDentifier AssignmentChar TemplateBody
4987   {
4988     $$.id = $1;
4989     $$.deftempl = $3;
4990     $$.yyloc = @$;
4991   }
4992 ;
4993
4994 /* A.1.6.1.13 */
4995 FriendModuleDef: // 289
4996   FriendKeyword TTCN3ModuleKeyword IdentifierList optSemiColon
4997   {
4998     $$.nElements = $3.nElements;
4999     $$.elements = (Ttcn::FriendMod**)
5000       Malloc($$.nElements*sizeof(*$$.elements));
5001     for (size_t i = 0; i < $$.nElements; i++) {
5002       $$.elements[i] = new FriendMod($3.elements[i].id);
5003       $$.elements[i]->set_location(infile, $3.elements[i].yyloc);
5004     }
5005     Free($3.elements);
5006   }
5007 ;
5008
5009 /* A.1.6.2 Control part */
5010
5011 /* A.1.6.2.0 General */
5012
5013 ModuleControlPart: // 290
5014   optError ControlKeyword
5015   '{' ModuleControlBody '}'
5016   optWithStatementAndSemiColon
5017   {
5018     ControlPart* controlpart = new ControlPart($4);
5019     controlpart->set_location(infile, @2, @6);
5020     controlpart->set_with_attr($6);
5021     controlpart->set_parent_path(act_ttcn3_module->get_attrib_path());
5022     act_ttcn3_module->add_controlpart(controlpart);
5023   }
5024 ;
5025
5026 ModuleControlBody: // 292
5027   /* empty */ optError { $$=new StatementBlock(); }
5028 | ControlStatementOrDefList { $$ = $1; }
5029 ;
5030
5031 ControlStatementOrDefList: // 293
5032   optError ControlStatementOrDef optSemiColon
5033   {
5034     $$=new StatementBlock();
5035     for(size_t i=0; i<$2.nElements; i++) $$->add_stmt($2.elements[i]);
5036     Free($2.elements);
5037   }
5038 | ControlStatementOrDefList optError ControlStatementOrDef optSemiColon
5039   {
5040     $$=$1;
5041     for(size_t i=0; i<$3.nElements; i++) $$->add_stmt($3.elements[i]);
5042     Free($3.elements);
5043   }
5044 ;
5045
5046 ControlStatementOrDef: // 294
5047   FunctionLocalDef
5048   {
5049     $$.nElements=$1.nElements;
5050     $$.elements=(Statement**)Malloc($$.nElements*sizeof(*$$.elements));
5051     for(size_t i=0; i<$1.nElements; i++) {
5052       $$.elements[i]=new Statement(Statement::S_DEF, $1.elements[i]);
5053       $$.elements[i]->set_location(*$1.elements[i]);
5054     }
5055     Free($1.elements);
5056   }
5057 |  FunctionLocalInst
5058   {
5059     $$.nElements=$1.nElements;
5060     $$.elements=(Statement**)Malloc($$.nElements*sizeof(*$$.elements));
5061     for(size_t i=0; i<$1.nElements; i++) {
5062       $$.elements[i]=new Statement(Statement::S_DEF, $1.elements[i]);
5063       $$.elements[i]->set_location(*$1.elements[i]);
5064     }
5065     Free($1.elements);
5066   }
5067 | ControlStatement
5068   {
5069     $$.nElements=1;
5070     $$.elements=(Statement**)Malloc($$.nElements*sizeof(*$$.elements));
5071     $$.elements[0]=$1;
5072   }
5073 ;
5074
5075 ControlStatement: /* Statement *stmt */ // 295
5076   TimerStatements { $$ = $1; }
5077 | BasicStatements { $$ = $1; }
5078 | BehaviourStatements { $$ = $1; }
5079 | SUTStatements { $$ = $1; }
5080 | StopExecutionStatement { $$ = $1; }
5081 ;
5082
5083 /* A.1.6.2.1 Variable instantiation */
5084
5085 VarInstance: // 296
5086   VarKeyword Type VarList
5087   {
5088     $$.nElements = $3.nElements;
5089     $$.elements = (Ttcn::Definition**)
5090       Malloc($$.nElements*sizeof(*$$.elements));
5091     for (size_t i = 0; i < $$.nElements; i++) {
5092       Type *type;
5093       if (i > 0) {
5094         type = new Type(Type::T_REFDSPEC, $2);
5095         type->set_location(*$2);
5096       } else type = $2;
5097       /* creation of array type(s) if necessary (from right to left) */
5098       for (size_t j = $3.elements[i].arrays.nElements; j > 0; j--) {
5099         type = new Type(Type::T_ARRAY, type,
5100           $3.elements[i].arrays.elements[j - 1], false);
5101         type->set_location(*$2);
5102       }
5103       Free($3.elements[i].arrays.elements);
5104
5105       /* Create the definition */
5106       $$.elements[i] = new Def_Var($3.elements[i].id,
5107                                    type, $3.elements[i].initial_value);
5108       $$.elements[i]->set_location(infile, $3.elements[i].yyloc);
5109     }
5110     Free($3.elements);
5111   }
5112 | VarKeyword TemplateOptRestricted Type TempVarList
5113   {
5114     $$.nElements = $4.nElements;
5115     $$.elements = (Ttcn::Definition**)
5116       Malloc($$.nElements * sizeof(*$$.elements));
5117     for (size_t i = 0; i < $$.nElements; i++) {
5118       Type *type;
5119       if (i > 0) {
5120         type = new Type(Type::T_REFDSPEC, $3);
5121         type->set_location(*$3);
5122       } else type = $3;
5123       /* creation of array type(s) if necessary (from right to left) */
5124       for (size_t j = $4.elements[i].arrays.nElements; j > 0; j--) {
5125         type = new Type(Type::T_ARRAY, type,
5126           $4.elements[i].arrays.elements[j - 1], false);
5127         type->set_location(*$3);
5128       }
5129       Free($4.elements[i].arrays.elements);
5130
5131       /* Create the definition */
5132       $$.elements[i] = new Def_Var_Template($4.elements[i].id, type,
5133                                             $4.elements[i].initial_value, $2);
5134       $$.elements[i]->set_location(infile, $4.elements[i].yyloc);
5135     }
5136
5137     Free($4.elements);
5138 }
5139 ;
5140
5141 VarList: // 297
5142   optError SingleVarInstance
5143   {
5144     $$.nElements = 1;
5145     $$.elements = (YYSTYPE::singlevarinst_t*)Malloc(sizeof(*$$.elements));
5146     $$.elements[0] = $2;
5147   }
5148 | VarList ',' optError SingleVarInstance
5149   {
5150     $$.nElements = $1.nElements + 1;
5151     $$.elements = (YYSTYPE::singlevarinst_t*)
5152       Realloc($1.elements, $$.nElements * sizeof(*$$.elements));
5153     $$.elements[$$.nElements - 1] = $4;
5154   }
5155 ;
5156
5157 SingleVarInstance: // 298
5158   IDentifier optArrayDef
5159   {
5160     $$.id = $1;
5161     $$.arrays = $2;
5162     $$.initial_value = 0;
5163     $$.yyloc = @$;
5164   }
5165 | IDentifier optArrayDef AssignmentChar Expression
5166   {
5167     $$.id = $1;
5168     $$.arrays = $2;
5169     $$.initial_value = $4;
5170     $$.yyloc = @$;
5171   }
5172 ;
5173
5174 TempVarList: // 302
5175   optError SingleTempVarInstance
5176   {
5177     $$.nElements = 1;
5178     $$.elements = (YYSTYPE::singletempvarinst_t*)Malloc(sizeof(*$$.elements));
5179     $$.elements[0] = $2;
5180   }
5181 | TempVarList ',' optError SingleTempVarInstance
5182   {
5183     $$.nElements = $1.nElements + 1;
5184     $$.elements = (YYSTYPE::singletempvarinst_t*)
5185       Realloc($1.elements, $$.nElements * sizeof(*$$.elements));
5186     $$.elements[$$.nElements - 1] = $4;
5187   }
5188 ;
5189
5190 SingleTempVarInstance: // 303
5191   IDentifier optArrayDef
5192   {
5193     $$.id = $1;
5194     $$.arrays = $2;
5195     $$.initial_value = NULL;
5196     $$.yyloc = @$;
5197   }
5198 | IDentifier optArrayDef AssignmentChar TemplateBody
5199   {
5200     $$.id = $1;
5201     $$.arrays = $2;
5202     $$.initial_value = $4;
5203     $$.yyloc = @$;
5204   }
5205 ;
5206
5207 VariableRef: // 305
5208   Reference
5209   {
5210     if ($1.is_ref) $$ = $1.ref;
5211     else {
5212       $$ = new Ttcn::Reference($1.id);
5213       $$->set_location(infile, @$);
5214     }
5215   }
5216 ;
5217
5218 /* A.1.6.2.2 Timer instantiation */
5219
5220 TimerInstance: // 306
5221   TimerKeyword TimerList { $$ = $2; }
5222 ;
5223
5224 TimerList: // 307
5225   optError SingleTimerInstance
5226   {
5227     $$.nElements = 1;
5228     $$.elements = (Ttcn::Definition**)Malloc(sizeof(*$$.elements));
5229     $$.elements[0] = $2;
5230   }
5231 | TimerList ',' optError SingleTimerInstance
5232   {
5233     $$.nElements = $1.nElements + 1;
5234     $$.elements = (Ttcn::Definition**)
5235       Realloc($1.elements, $$.nElements * sizeof(*$$.elements));
5236     $$.elements[$$.nElements - 1] = $4;
5237   }
5238 ;
5239
5240 SingleTimerInstance: // 308
5241   IDentifier optArrayDef
5242   {
5243     ArrayDimensions *dims;
5244     if ($2.nElements > 0) {
5245       dims = new ArrayDimensions;
5246       for (size_t i = 0; i < $2.nElements; i++) dims->add($2.elements[i]);
5247       Free($2.elements);
5248     } else dims = 0;
5249     $$ = new Ttcn::Def_Timer($1, dims, 0);
5250     $$->set_location(infile, @$);
5251   }
5252 | IDentifier optArrayDef AssignmentChar TimerValue
5253   {
5254     ArrayDimensions *dims;
5255     if ($2.nElements > 0) {
5256       dims = new ArrayDimensions;
5257       for (size_t i = 0; i < $2.nElements; i++) dims->add($2.elements[i]);
5258       Free($2.elements);
5259     } else dims = 0;
5260     $$ = new Ttcn::Def_Timer($1, dims, $4);
5261     $$->set_location(infile, @$);
5262   }
5263 ;
5264
5265 TimerValue: // 311
5266   Expression { $$ = $1; }
5267 ;
5268
5269 TimerRef: // 312
5270   VariableRef { $$ = $1; }
5271 ;
5272
5273 /* A.1.6.2.3 Component operations */
5274
5275 ConfigurationStatements: // 313
5276   ConnectStatement { $$ = $1; }
5277 | MapStatement { $$ = $1; }
5278 | DisconnectStatement { $$ = $1; }
5279 | UnmapStatement { $$ = $1; }
5280 | DoneStatement { $$ = $1; }
5281 | KilledStatement { $$ = $1; }
5282 | StartTCStatement { $$ = $1; }
5283 | StopTCStatement { $$ = $1; }
5284 | KillTCStatement { $$ = $1; }
5285 ;
5286
5287 ConfigurationOps: // 314
5288   CreateOp {$$=$1;}
5289 | SelfOp {$$=$1;}
5290 | SystemOp {$$=$1;}
5291 | MTCOp {$$=$1;}
5292 | RunningOp {$$=$1;}
5293 | AliveOp { $$ = $1; }
5294 ;
5295
5296 CreateOp: // 315
5297   VariableRef DotCreateKeyword optCreateParameter optAliveKeyword
5298   {
5299     $$ = new Value(Value::OPTYPE_COMP_CREATE, $1, $3.name, $3.loc, $4);
5300     $$->set_location(infile, @$);
5301   }
5302 ;
5303
5304 optCreateParameter:
5305   /* empty */
5306   {
5307     $$.name=0;
5308     $$.loc=0;
5309   }
5310 | '(' optError Expression optError ')'
5311   {
5312     $$.name = $3;
5313     $$.loc = 0;
5314   }
5315 | '(' optError Expression optError ',' optError Expression optError ')'
5316   {
5317     $$.name = $3;
5318     $$.loc = $7;
5319   }
5320 | '(' optError NotUsedSymbol optError ',' optError Expression optError ')'
5321   {
5322     $$.name = 0;
5323     $$.loc = $7;
5324   }
5325 | '(' error ')'
5326   {
5327     $$.name = 0;
5328     $$.loc = 0;
5329   }
5330 ;
5331
5332 optAliveKeyword: // [328]
5333   /* empty */ { $$ = false; }
5334 | AliveKeyword { $$ = true; }
5335 ;
5336
5337 SystemOp: // 316
5338   SystemKeyword
5339   {
5340     $$=new Value(Value::OPTYPE_COMP_SYSTEM);
5341     $$->set_location(infile, @$);
5342   }
5343 ;
5344
5345 SelfOp: // 317
5346   SelfKeyword
5347   {
5348     $$=new Value(Value::OPTYPE_COMP_SELF);
5349     $$->set_location(infile, @$);
5350   }
5351 ;
5352
5353 MTCOp: // 318
5354   MTCKeyword
5355   {
5356     $$=new Value(Value::OPTYPE_COMP_MTC);
5357     $$->set_location(infile, @$);
5358   }
5359 ;
5360
5361 DoneStatement: // 319
5362   ComponentOrDefaultReference DotDoneKeyword optDoneParameter
5363   {
5364     $$ = new Statement(Statement::S_DONE, $1, $3.donematch, $3.redirect);
5365     $$->set_location(infile, @$);
5366   }
5367 | AnyKeyword ComponentKeyword DotDoneKeyword
5368   {
5369     $$ = new Statement(Statement::S_DONE, Statement::C_ANY);
5370     $$->set_location(infile, @$);
5371   }
5372 | AllKeyword ComponentKeyword DotDoneKeyword
5373   {
5374     $$ = new Statement(Statement::S_DONE, Statement::C_ALL);
5375     $$->set_location(infile, @$);
5376   }
5377 ;
5378
5379 optDoneParameter:
5380   optReceiveParameter
5381   {
5382     $$.donematch = $1;
5383     $$.redirect = 0;
5384   }
5385 | optReceiveParameter PortRedirectSymbol ValueSpec
5386   {
5387     $$.donematch = $1;
5388     $$.redirect = $3;
5389   }
5390 ;
5391
5392 KilledStatement: // 320
5393   ComponentOrDefaultReference DotKilledKeyword
5394   {
5395     $$ = new Statement(Statement::S_KILLED, $1);
5396     $$->set_location(infile, @$);
5397   }
5398 | AnyKeyword ComponentKeyword DotKilledKeyword
5399   {
5400     $$ = new Statement(Statement::S_KILLED, Statement::C_ANY);
5401     $$->set_location(infile, @$);
5402   }
5403 | AllKeyword ComponentKeyword DotKilledKeyword
5404   {
5405     $$ = new Statement(Statement::S_KILLED, Statement::C_ALL);
5406     $$->set_location(infile, @$);
5407   }
5408 ;
5409
5410 /*
5411 ComponentId: // 321
5412   ComponentOrDefaultReference
5413 | AnyKeyword ComponentKeyword
5414 | AllKeyword ComponentKeyword
5415 ;
5416 */
5417
5418 RunningOp: // 324
5419 /*  VariableRef DotRunningKeyword -- covered by RunningTimerOp */
5420   FunctionInstance DotRunningKeyword
5421   {
5422     Value *t_val = new Value(Value::V_REFD, $1);
5423     t_val->set_location(infile, @1);
5424     $$ = new Value(Value::OPTYPE_COMP_RUNNING, t_val);
5425     $$->set_location(infile, @$);
5426   }
5427 | ApplyOp DotRunningKeyword
5428   {
5429     Value *t_val = new Value(Value::V_INVOKE, $1.value, $1.ap_list);
5430     t_val->set_location(infile, @1);
5431     $$ = new Value(Value::OPTYPE_COMP_RUNNING, t_val);
5432     $$->set_location(infile, @$);
5433   }
5434 | AnyKeyword ComponentKeyword DotRunningKeyword
5435   {
5436     $$ = new Value(Value::OPTYPE_COMP_RUNNING_ANY);
5437     $$->set_location(infile, @$);
5438   }
5439 | AllKeyword ComponentKeyword DotRunningKeyword
5440   {
5441     $$ = new Value(Value::OPTYPE_COMP_RUNNING_ALL);
5442     $$->set_location(infile, @$);
5443   }
5444 ;
5445
5446 AliveOp: // 326
5447   ComponentOrDefaultReference DotAliveKeyword
5448   {
5449     $$ = new Value(Value::OPTYPE_COMP_ALIVE, $1);
5450     $$->set_location(infile, @$);
5451   }
5452 | AnyKeyword ComponentKeyword DotAliveKeyword
5453   {
5454     $$ = new Value(Value::OPTYPE_COMP_ALIVE_ANY);
5455     $$->set_location(infile, @$);
5456   }
5457 | AllKeyword ComponentKeyword DotAliveKeyword
5458   {
5459     $$ = new Value(Value::OPTYPE_COMP_ALIVE_ALL);
5460     $$->set_location(infile, @$);
5461   }
5462 ;
5463
5464 ConnectStatement: // 329
5465   ConnectKeyword SingleConnectionSpec
5466   {
5467     $$=new Statement(Statement::S_CONNECT,
5468                      $2.compref1, $2.portref1, $2.compref2, $2.portref2);
5469     $$->set_location(infile, @$);
5470   }
5471 ;
5472
5473 SingleConnectionSpec: // 331
5474   '(' PortRef optError ',' optError PortRef optError ')'
5475   {
5476     $$.compref1 = $2.compref;
5477     $$.portref1 = $2.portref;
5478     $$.compref2 = $6.compref;
5479     $$.portref2 = $6.portref;
5480   }
5481 ;
5482
5483 PortRef: // 332
5484   ComponentRef ':' Port
5485   {
5486     $$.compref = $1;
5487     $$.portref = $3;
5488   }
5489 ;
5490
5491 ComponentRef: // 333
5492   ComponentOrDefaultReference { $$ = $1; }
5493 | SystemOp { $$ = $1; }
5494 | SelfOp { $$ = $1; }
5495 | MTCOp { $$ = $1; }
5496 ;
5497
5498 DisconnectStatement: // 335
5499   DisconnectKeyword
5500   {
5501     Location loc(infile, @$);
5502     loc.error("Disconnect operation on multiple connections is "
5503       "not currently supported");
5504     $$ = new Statement(Statement::S_ERROR);
5505     $$->set_location(infile, @$);
5506   }
5507 | DisconnectKeyword SingleOrMultiConnectionSpec
5508   {
5509     if ($2.compref1 && $2.portref1 && $2.compref1 && $2.compref2) {
5510       $$ = new Statement(Statement::S_DISCONNECT,
5511         $2.compref1, $2.portref1, $2.compref2, $2.portref2);
5512     } else {
5513       Location loc(infile, @$);
5514       loc.error("Disconnect operation on multiple connections is "
5515         "not currently supported");
5516       delete $2.compref1;
5517       delete $2.portref1;
5518       delete $2.compref2;
5519       delete $2.portref2;
5520       $$ = new Statement(Statement::S_ERROR);
5521     }
5522     $$->set_location(infile, @$);
5523   }
5524 ;
5525
5526 SingleOrMultiConnectionSpec: // 336
5527   SingleConnectionSpec { $$ = $1; }
5528 | AllConnectionsSpec
5529   {
5530     $$.compref1 = $1.compref;
5531     $$.portref1 = $1.portref;
5532     $$.compref2 = 0;
5533     $$.portref2 = 0;
5534   }
5535 | AllPortsSpec
5536   {
5537     $$.compref1 = $1;
5538     $$.portref1 = 0;
5539     $$.compref2 = 0;
5540     $$.portref2 = 0;
5541   }
5542 | AllCompsAllPortsSpec
5543   {
5544     $$.compref1 = 0;
5545     $$.portref1 = 0;
5546     $$.compref2 = 0;
5547     $$.portref2 = 0;
5548   }
5549 ;
5550
5551 AllConnectionsSpec: // 337
5552   '(' PortRef optError ')' { $$ = $2; }
5553 ;
5554
5555 AllPortsSpec: // 338
5556   '(' ComponentRef ':' AllKeyword PortKeyword optError ')' { $$ = $2; }
5557 ;
5558
5559 AllCompsAllPortsSpec: // 339
5560   '(' AllKeyword ComponentKeyword ':' AllKeyword PortKeyword optError ')'
5561 ;
5562
5563 MapStatement: // 341
5564   MapKeyword SingleConnectionSpec
5565   {
5566     $$=new Statement(Statement::S_MAP,
5567                      $2.compref1, $2.portref1,
5568                      $2.compref2, $2.portref2);
5569     $$->set_location(infile, @$);
5570   }
5571 ;
5572
5573 UnmapStatement: // 343
5574   UnmapKeyword
5575   {
5576     $$ = new Statement(Statement::S_ERROR);
5577     $$->set_location(infile, @$);
5578     Location loc(infile, @$);
5579     loc.error("Unmap operation on multiple mappings is "
5580       "not currently supported");
5581   }
5582 | UnmapKeyword SingleOrMultiConnectionSpec
5583   {
5584     if ($2.compref1 && $2.portref1 && $2.compref1 && $2.compref2) {
5585       $$ = new Statement(Statement::S_UNMAP,
5586         $2.compref1, $2.portref1, $2.compref2, $2.portref2);
5587     } else {
5588       Location loc(infile, @$);
5589       loc.error("Unmap operation on multiple mappings is "
5590         "not currently supported");
5591       delete $2.compref1;
5592       delete $2.portref1;
5593       delete $2.compref2;
5594       delete $2.portref2;
5595       $$ = new Statement(Statement::S_ERROR);
5596     }
5597     $$->set_location(infile, @$);
5598   }
5599 ;
5600
5601 StartTCStatement: // 345
5602 /* VariableRef DotStartKeyword '(' FunctionInstance ')'
5603   -- covered by StartTimerStatement */
5604   VariableRef DotStartKeyword '(' DereferOp '(' optFunctionActualParList ')'
5605   optError ')'
5606   {
5607     Value *t_val = new Value(Value::V_REFD, $1);
5608     t_val->set_location(infile, @1);
5609     $6->set_location(infile, @5, @7);
5610     //ParsedActualParameters *pap = new ParsedActualParameters($6);
5611     $$ = new Statement(Statement::S_START_COMP_REFD, t_val, $4, $6);
5612     $$->set_location(infile, @$);
5613   }
5614 | FunctionInstance DotStartKeyword '(' FunctionInstance optError ')'
5615   {
5616     Value *t_val = new Value(Value::V_REFD, $1);
5617     t_val->set_location(infile, @1);
5618     $$ = new Statement(Statement::S_START_COMP, t_val, $4);
5619     $$->set_location(infile, @$);
5620   }
5621 | FunctionInstance DotStartKeyword '(' DereferOp '('
5622     optFunctionActualParList ')' optError ')'
5623   {
5624     Value *t_val = new Value(Value::V_REFD, $1);
5625     t_val->set_location(infile, @1);
5626     $6->set_location(infile, @5 , @7);
5627     $$ = new Statement(Statement::S_START_COMP_REFD, t_val, $4, $6);
5628     $$->set_location(infile, @$);
5629   }
5630 | FunctionInstance DotStartKeyword '(' error ')'
5631   {
5632     delete $1;
5633     $$ = new Statement(Statement::S_ERROR);
5634     $$->set_location(infile, @$);
5635   }
5636 | ApplyOp DotStartKeyword '(' FunctionInstance ')'
5637   {
5638     Value *t_val = new Value(Value::V_INVOKE, $1.value, $1.ap_list);
5639     t_val->set_location(infile, @1);
5640     $$ = new Statement(Statement::S_START_COMP, t_val, $4);
5641     $$->set_location(infile, @$);
5642   }
5643 | ApplyOp DotStartKeyword '(' DereferOp '(' optFunctionActualParList ')'
5644   optError ')'
5645   {
5646     Value *t_val = new Value(Value::V_INVOKE, $1.value, $1.ap_list);
5647     t_val->set_location(infile, @1);
5648     $6->set_location(infile, @5 , @7);
5649     $$ = new Statement(Statement::S_START_COMP_REFD, t_val, $4, $6);
5650     $$->set_location(infile, @$);
5651   }
5652 | ApplyOp DotStartKeyword '(' error ')'
5653   {
5654     delete $1.value;
5655     delete $1.ap_list;
5656     $$ = new Statement(Statement::S_ERROR);
5657     $$->set_location(infile, @$);
5658   }
5659 ;
5660
5661 StopTCStatement: // 337
5662 /* VariableRef DotStopKeyword -- covered by StopTimerStatement */
5663   FunctionInstance DotStopKeyword
5664   {
5665     Value *t_val = new Value(Value::V_REFD, $1);
5666     t_val->set_location(infile, @1);
5667     $$ = new Statement(Statement::S_STOP_COMP, t_val);
5668     $$->set_location(infile, @$);
5669   }
5670 | ApplyOp DotStopKeyword
5671   {
5672     Value *t_val = new Value(Value::V_INVOKE, $1.value, $1.ap_list);
5673     t_val->set_location(infile, @1);
5674     $$ = new Statement(Statement::S_STOP_COMP, t_val);
5675     $$->set_location(infile, @$);
5676   }
5677 | MTCOp DotStopKeyword
5678   {
5679     $$ = new Statement(Statement::S_STOP_COMP, $1);
5680     $$->set_location(infile, @$);
5681   }
5682 | SelfOp DotStopKeyword
5683   {
5684     $$ = new Statement(Statement::S_STOP_COMP, $1);
5685     $$->set_location(infile, @$);
5686   }
5687 | AllKeyword ComponentKeyword DotStopKeyword
5688   {
5689     $$ = new Statement(Statement::S_STOP_COMP, (Value*)0);
5690     $$->set_location(infile, @$);
5691   }
5692 ;
5693
5694 ComponentReferenceOrLiteral: // 348
5695   ComponentOrDefaultReference { $$ = $1; }
5696 | MTCOp { $$ = $1; }
5697 | SelfOp { $$ = $1; }
5698 ;
5699
5700 KillTCStatement: // 349
5701   KillKeyword
5702   {
5703     Value *self = new Value(Value::OPTYPE_COMP_SELF);
5704     self->set_location(infile, @1);
5705     $$ = new Statement(Statement::S_KILL, self);
5706     $$->set_location(infile, @$);
5707   }
5708 | ComponentReferenceOrLiteral DotKillKeyword
5709   {
5710     $$ = new Statement(Statement::S_KILL, $1);
5711     $$->set_location(infile, @$);
5712   }
5713 | AllKeyword ComponentKeyword DotKillKeyword
5714   {
5715     $$ = new Statement(Statement::S_KILL, (Value*)0);
5716     $$->set_location(infile, @$);
5717   }
5718 ;
5719
5720 ComponentOrDefaultReference: // 350
5721   VariableRef
5722   {
5723     $$ = new Value(Value::V_REFD, $1);
5724     $$->set_location(infile, @$);
5725   }
5726 | FunctionInstance
5727   {
5728     $$ = new Value(Value::V_REFD, $1);
5729     $$->set_location(infile, @$);
5730   }
5731 | ApplyOp
5732   {
5733     $$ = new Value(Value::V_INVOKE, $1.value, $1.ap_list);
5734     $$->set_location(infile, @$);
5735   }
5736 ;
5737
5738 /* A.1.6.2.4 Port operations */
5739
5740 Port: // 325
5741   VariableRef { $$ = $1; }
5742 ;
5743
5744 CommunicationStatements: // 353
5745   SendStatement {$$ = $1;}
5746 | CallStatement {$$ = $1;}
5747 | ReplyStatement {$$ = $1;}
5748 | RaiseStatement {$$ = $1;}
5749 | ReceiveStatement {$$ = $1;}
5750 | TriggerStatement {$$ = $1;}
5751 | GetCallStatement {$$ = $1;}
5752 | GetReplyStatement {$$ = $1;}
5753 | CatchStatement {$$ = $1;}
5754 | CheckStatement {$$ = $1;}
5755 | ClearStatement {$$ = $1;}
5756 | StartStatement {$$ = $1;}
5757 | StopStatement {$$ = $1;}
5758 | HaltStatement { $$ = $1; }
5759 ;
5760
5761 SendStatement: // 354
5762   Port DotSendOpKeyword PortSendOp
5763   {
5764     $$ = new Statement(Statement::S_SEND, $1, $3.templ_inst, $3.val);
5765     $$->set_location(infile, @$);
5766   }
5767 ;
5768
5769 PortSendOp: // 355
5770   '(' SendParameter optError ')' optToClause
5771   {
5772     $$.templ_inst = $2;
5773     $$.val = $5;
5774   }
5775 | '(' error ')' optToClause
5776   {
5777     Template *t = new Template(Template::TEMPLATE_ERROR);
5778     t->set_location(infile, @2);
5779     $$.templ_inst = new TemplateInstance(0, 0, t);
5780     $$.templ_inst->set_location(infile, @2);
5781     $$.val = $4;
5782   }
5783 ;
5784
5785 SendParameter: // 357
5786   TemplateInstance { $$=$1; }
5787 ;
5788
5789 optToClause: // [3583]
5790   /* empty */ { $$ = 0; }
5791 | ToKeyword AddressRef
5792   {
5793     Template *templ = $2->get_Template();
5794     if (!$2->get_Type() && !$2->get_DerivedRef() && templ->is_Value()) {
5795       $$ = templ->get_Value();
5796     } else {
5797       Location loc(infile, @$);
5798       loc.error("Multicast communication is not currently supported");
5799       $$ = 0;
5800     }
5801     delete $2;
5802   }
5803 /* | ToKeyword AddressRefList -- covered by the previous rule
5804    (as ValueOrAttribList) */
5805 | ToKeyword AllKeyword ComponentKeyword
5806   {
5807     Location loc(infile, @$);
5808     loc.error("Broadcast communication is not currently supported");
5809     $$ = 0;
5810   }
5811 | ToKeyword error { $$ = 0; }
5812 ;
5813
5814 /*
5815 AddressRefList: // 359
5816   '(' seqAddressRef ')'
5817 ;
5818
5819 seqAddressRef:
5820   AddressRef
5821 | seqAddressRef ',' AddressRef
5822 ;
5823 */
5824
5825 AddressRef: // 361
5826   TemplateInstance { $$ = $1; }
5827 ;
5828
5829 CallStatement: // 362
5830   Port DotCallOpKeyword PortCallOp optPortCallBody
5831   {
5832     $$ = new Statement(Statement::S_CALL, $1, $3.templ_inst,
5833                        $3.calltimerval, $3.nowait, $3.val, $4);
5834     $$->set_location(infile, @$);
5835   }
5836 ;
5837
5838 PortCallOp: // 363
5839   '(' CallParameters optError ')' optToClause
5840   {
5841     $$.templ_inst = $2.templ_inst;
5842     $$.calltimerval = $2.calltimerval;
5843     $$.nowait = $2.nowait;
5844     $$.val = $5;
5845   }
5846 | '(' error ')' optToClause
5847   {
5848     Template *t = new Template(Template::TEMPLATE_ERROR);
5849     t->set_location(infile, @2);
5850     $$.templ_inst = new TemplateInstance(0, 0, t);
5851     $$.templ_inst->set_location(infile, @2);
5852     $$.calltimerval = 0;
5853     $$.nowait = false;
5854     $$.val = $4;
5855   }
5856 ;
5857
5858 CallParameters: // 365
5859   TemplateInstance
5860   {
5861     $$.templ_inst=$1;
5862     $$.calltimerval=0;
5863     $$.nowait=false;
5864   }
5865 | TemplateInstance ',' optError CallTimerValue
5866   {
5867     $$.templ_inst=$1;
5868     $$.calltimerval=$4.calltimerval;
5869     $$.nowait=$4.nowait;
5870   }
5871 ;
5872
5873 CallTimerValue: // 366
5874   TimerValue
5875   {
5876     $$.calltimerval=$1;
5877     $$.nowait=false;
5878   }
5879 | NowaitKeyword
5880   {
5881     $$.calltimerval=0;
5882     $$.nowait=true;
5883   }
5884 ;
5885
5886 optPortCallBody: // [368]
5887   /* empty */ { $$=0; }
5888 | '{' CallBodyStatementList optError '}' { $$=$2; }
5889 | '{' error '}' { $$ = new AltGuards; }
5890 ;
5891
5892 CallBodyStatementList: // 369
5893   optError CallBodyStatement
5894   {
5895     $$=new AltGuards();
5896     $$->add_ag($2);
5897   }
5898 | CallBodyStatementList optError CallBodyStatement
5899   {
5900     $$=$1;
5901     $$->add_ag($3);
5902   }
5903 ;
5904
5905 CallBodyStatement: // 370 and 371. rolled into one.
5906   AltGuardChar CallBodyOps ';' // This alternative is a TITAN extension
5907   {
5908     $$=new AltGuard($1, $2, new StatementBlock());
5909     $$->set_location(infile, @$);
5910   }
5911 | AltGuardChar CallBodyOps optSemiColon StatementBlock optSemiColon
5912   {
5913     $$=new AltGuard($1, $2, $4);
5914     $$->set_location(infile, @$);
5915   }
5916 ;
5917
5918 CallBodyOps: // 372
5919   GetReplyStatement {$$=$1;}
5920 | CatchStatement {$$=$1;}
5921 ;
5922
5923 ReplyStatement: // 373
5924   Port DotReplyKeyword PortReplyOp
5925   {
5926     $$ = new Statement(Statement::S_REPLY, $1, $3.templ_inst,
5927                        $3.replyval, $3.toclause);
5928     $$->set_location(infile, @$);
5929   }
5930 ;
5931
5932 PortReplyOp: // 374
5933   '(' TemplateInstance optReplyValue optError ')' optToClause
5934   {
5935     $$.templ_inst = $2;
5936     $$.replyval = $3;
5937     $$.toclause = $6;
5938   }
5939 | '(' error ')' optToClause
5940   {
5941     Template *t = new Template(Template::TEMPLATE_ERROR);
5942     t->set_location(infile, @2);
5943     $$.templ_inst = new TemplateInstance(0, 0, t);
5944     $$.templ_inst->set_location(infile, @2);
5945     $$.replyval = 0;
5946     $$.toclause = $4;
5947   }
5948 ;
5949
5950 optReplyValue: // [376]
5951   /* empty */ { $$=0; }
5952 | ValueKeyword Expression { $$=$2; }
5953 | ValueKeyword error { $$ = 0; }
5954 ;
5955
5956 RaiseStatement: // 377
5957   Port DotRaiseKeyword PortRaiseOp
5958   {
5959     if ($3.signature) $$ = new Statement(Statement::S_RAISE, $1,
5960       $3.signature, $3.templ_inst, $3.toclause);
5961     else {
5962       $$ = new Statement(Statement::S_ERROR);
5963       delete $1;
5964       delete $3.signature;
5965       delete $3.templ_inst;
5966       delete $3.toclause;
5967     }
5968     $$->set_location(infile, @$);
5969   }
5970 ;
5971
5972 PortRaiseOp: // 378
5973   '(' Signature optError ',' optError TemplateInstance optError ')' optToClause
5974   {
5975     $$.signature = $2;
5976     $$.templ_inst = $6;
5977     $$.toclause = $9;
5978   }
5979 | '(' error ')' optToClause
5980   {
5981     $$.signature = 0;
5982     $$.templ_inst = 0;
5983     $$.toclause = 0;
5984     delete $4;
5985   }
5986 ;
5987
5988 ReceiveStatement: // 380
5989   PortOrAny DotReceiveOpKeyword PortReceiveOp
5990   {
5991     $$ = new Statement(Statement::S_RECEIVE, $1, $3.templ_inst,
5992                        $3.fromclause, $3.redirectval, $3.redirectsender);
5993     $$->set_location(infile, @$);
5994   }
5995 ;
5996
5997 PortOrAny: // 381
5998   Port { $$ = $1; }
5999 | AnyKeyword PortKeyword { $$ = 0; }
6000 ;
6001
6002 PortReceiveOp: // 382
6003   optReceiveParameter optFromClause optPortRedirect
6004   {
6005     $$.templ_inst = $1;
6006     $$.fromclause = $2;
6007     $$.redirectval = $3.redirectval;
6008     $$.redirectsender = $3.redirectsender;
6009   }
6010 ;
6011
6012 optReceiveParameter: // [384]
6013   /* empty */ { $$ = 0; }
6014 | '(' ReceiveParameter optError ')' { $$ = $2; }
6015 | '(' error ')'
6016   {
6017     Template *t = new Template(Template::TEMPLATE_ERROR);
6018     t->set_location(infile, @2);
6019     $$ = new TemplateInstance(0, 0, t);
6020     $$->set_location(infile, @$);
6021   }
6022 ;
6023
6024 ReceiveParameter: // 384
6025   TemplateInstance { $$ = $1; }
6026 ;
6027
6028 optFromClause: // [385]
6029   /* empty */ { $$=0; }
6030 | FromClause { $$=$1; }
6031 ;
6032
6033 FromClause: // 385
6034   FromKeyword AddressRef { $$=$2; }
6035 | FromKeyword error { $$ = 0; }
6036 ;
6037
6038 optPortRedirect: // [387]
6039   /* empty */
6040   {
6041     $$.redirectval=0;
6042     $$.redirectsender=0;
6043   }
6044 | PortRedirectSymbol ValueSpec
6045   {
6046     $$.redirectval=$2;
6047     $$.redirectsender=0;
6048   }
6049 | PortRedirectSymbol SenderSpec
6050   {
6051     $$.redirectval=0;
6052     $$.redirectsender=$2;
6053   }
6054 | PortRedirectSymbol ValueSpec SenderSpec
6055   {
6056     $$.redirectval=$2;
6057     $$.redirectsender=$3;
6058   }
6059 | PortRedirectSymbol error
6060   {
6061     $$.redirectval=0;
6062     $$.redirectsender=0;
6063   }
6064 ;
6065
6066 ValueSpec: // 389
6067   ValueKeyword VariableRef { $$ = $2; }
6068 | ValueKeyword error { $$ = 0; }
6069 ;
6070
6071 SenderSpec: // 391
6072   SenderKeyword VariableRef { $$ = $2; }
6073 | SenderKeyword error { $$ = 0; }
6074 ;
6075
6076 TriggerStatement: // 393
6077   PortOrAny DotTriggerOpKeyword PortTriggerOp
6078   {
6079     $$ = new Statement(Statement::S_TRIGGER, $1, $3.templ_inst,
6080                        $3.fromclause, $3.redirectval, $3.redirectsender);
6081     $$->set_location(infile, @$);
6082   }
6083 ;
6084
6085 PortTriggerOp: // 394
6086   optReceiveParameter optFromClause optPortRedirect
6087   {
6088     $$.templ_inst = $1;
6089     $$.fromclause = $2;
6090     $$.redirectval = $3.redirectval;
6091     $$.redirectsender = $3.redirectsender;
6092   }
6093 ;
6094
6095 GetCallStatement: // 396
6096   PortOrAny DotGetCallOpKeyword PortGetCallOp
6097   {
6098     $$ = new Statement(Statement::S_GETCALL, $1, $3.templ_inst,
6099                        $3.fromclause, $3.redirectparam, $3.redirectsender);
6100     $$->set_location(infile, @$);
6101   }
6102 ;
6103
6104 PortGetCallOp: // 397
6105   optReceiveParameter optFromClause optPortRedirectWithParam
6106   {
6107     $$.templ_inst = $1;
6108     $$.fromclause = $2;
6109     $$.redirectparam = $3.redirectparam;
6110     $$.redirectsender = $3.redirectsender;
6111   }
6112 ;
6113
6114 optPortRedirectWithParam: // [399]
6115   /* empty */
6116   {
6117     $$.redirectparam=0;
6118     $$.redirectsender=0;
6119   }
6120 | PortRedirectSymbol ParamSpec
6121   {
6122     $$.redirectparam=$2;
6123     $$.redirectsender=0;
6124   }
6125 | PortRedirectSymbol ParamSpec SenderSpec
6126   {
6127     $$.redirectparam=$2;
6128     $$.redirectsender=$3;
6129   }
6130 | PortRedirectSymbol SenderSpec
6131   {
6132     $$.redirectparam=0;
6133     $$.redirectsender=$2;
6134   }
6135 | PortRedirectSymbol error
6136   {
6137     $$.redirectparam=0;
6138     $$.redirectsender=0;
6139   }
6140 ;
6141
6142 ParamSpec: // 401
6143   ParamKeyword ParamAssignmentList { $$ = $2; }
6144 | ParamKeyword error { $$ = 0; }
6145 ;
6146
6147 ParamAssignmentList: // 403
6148   '(' AssignmentList optError ')'
6149   {
6150     $$=new ParamRedirect($2);
6151     $$->set_location(infile, @$);
6152   }
6153 | '(' VariableList optError ')'
6154   {
6155     $$=new ParamRedirect($2);
6156     $$->set_location(infile, @$);
6157   }
6158 | '(' error ')'
6159   {
6160     $$=new ParamRedirect(new ParamAssignments());
6161     $$->set_location(infile, @$);
6162   }
6163 ;
6164
6165 AssignmentList: // 404
6166   VariableAssignment
6167   {
6168     $$ = new ParamAssignments();
6169     $$->add_parass($1);
6170   }
6171 | error VariableAssignment
6172   {
6173     $$ = new ParamAssignments();
6174     $$->add_parass($2);
6175   }
6176 | AssignmentList optError ',' optError VariableAssignment
6177   {
6178     $$ = $1;
6179     $$->add_parass($5);
6180   }
6181 | AssignmentList optError ',' error { $$ = $1; }
6182 ;
6183
6184 VariableAssignment: // 405
6185   VariableRef AssignmentChar IDentifier
6186   {
6187     $$ = new ParamAssignment($3, $1);
6188     $$->set_location(infile, @$);
6189   }
6190 ;
6191
6192 VariableList: // 407
6193   VariableEntry
6194   {
6195     $$ = new VariableEntries();
6196     $$->add_ve($1);
6197   }
6198 | error VariableEntry
6199   {
6200     $$ = new VariableEntries();
6201     $$->add_ve($2);
6202   }
6203 | VariableList optError ',' optError VariableEntry
6204   {
6205     $$ = $1;
6206     $$->add_ve($5);
6207   }
6208 | VariableList optError ',' error { $$ = $1; }
6209 ;
6210
6211 VariableEntry: // 408
6212   VariableRef
6213   {
6214     $$ = new VariableEntry($1);
6215     $$->set_location(infile, @$);
6216   }
6217 | NotUsedSymbol
6218   {
6219     $$ = new VariableEntry;
6220     $$->set_location(infile, @$);
6221   }
6222 ;
6223
6224 GetReplyStatement: // 409
6225   PortOrAny DotGetReplyOpKeyword PortGetReplyOp
6226   {
6227     $$ = new Statement(Statement::S_GETREPLY, $1, $3.templ_inst,
6228                        $3.valuematch, $3.fromclause, $3.redirectval,
6229                        $3.redirectparam, $3.redirectsender);
6230     $$->set_location(infile, @$);
6231   }
6232 ;
6233
6234 PortGetReplyOp: // 410
6235   optGetReplyParameter optFromClause optPortRedirectWithValueAndParam
6236   {
6237     $$.templ_inst = $1.templ_inst;
6238     $$.valuematch = $1.valuematch;
6239     $$.fromclause = $2;
6240     $$.redirectval = $3.redirectval;
6241     $$.redirectparam = $3.redirectparam;
6242     $$.redirectsender = $3.redirectsender;
6243   }
6244 ;
6245
6246 optPortRedirectWithValueAndParam: // [411]
6247   /* empty */
6248   {
6249     $$.redirectval=0;
6250     $$.redirectparam=0;
6251     $$.redirectsender=0;
6252   }
6253 | PortRedirectSymbol ValueSpec
6254   {
6255     $$.redirectval=$2;
6256     $$.redirectparam=0;
6257     $$.redirectsender=0;
6258   }
6259 | PortRedirectSymbol ValueSpec ParamSpec
6260   {
6261     $$.redirectval=$2;
6262     $$.redirectparam=$3;
6263     $$.redirectsender=0;
6264   }
6265 | PortRedirectSymbol ValueSpec SenderSpec
6266   {
6267     $$.redirectval=$2;
6268     $$.redirectparam=0;
6269     $$.redirectsender=$3;
6270   }
6271 | PortRedirectSymbol ValueSpec ParamSpec SenderSpec
6272   {
6273     $$.redirectval=$2;
6274     $$.redirectparam=$3;
6275     $$.redirectsender=$4;
6276   }
6277 | PortRedirectSymbol ParamSpec
6278   {
6279     $$.redirectval=0;
6280     $$.redirectparam=$2;
6281     $$.redirectsender=0;
6282   }
6283 | PortRedirectSymbol SenderSpec
6284   {
6285     $$.redirectval=0;
6286     $$.redirectparam=0;
6287     $$.redirectsender=$2;
6288   }
6289 | PortRedirectSymbol ParamSpec SenderSpec
6290   {
6291     $$.redirectval=0;
6292     $$.redirectparam=$2;
6293     $$.redirectsender=$3;
6294   }
6295 | PortRedirectSymbol error
6296   {
6297     $$.redirectval=0;
6298     $$.redirectparam=0;
6299     $$.redirectsender=0;
6300   }
6301 ;
6302
6303 optGetReplyParameter:
6304   /* empty */
6305   {
6306     $$.templ_inst=0;
6307     $$.valuematch=0;
6308   }
6309 | '(' ReceiveParameter optError ')'
6310   {
6311     $$.templ_inst=$2;
6312     $$.valuematch=0;
6313   }
6314 | '(' ReceiveParameter ValueMatchSpec optError ')'
6315   {
6316     $$.templ_inst=$2;
6317     $$.valuematch=$3;
6318   }
6319 | '(' error ')'
6320   {
6321     Template *t = new Template(Template::TEMPLATE_ERROR);
6322     t->set_location(infile, @2);
6323     $$.templ_inst = new TemplateInstance(0, 0, t);
6324     $$.templ_inst->set_location(infile, @2);
6325     $$.valuematch = 0;
6326   }
6327 ;
6328
6329 ValueMatchSpec: // 414
6330   ValueKeyword TemplateInstance { $$=$2; }
6331 | ValueKeyword error { $$ = 0; }
6332 ;
6333
6334 CheckStatement: // 415
6335   PortOrAny DotCheckOpKeyword optCheckParameter
6336   {
6337     switch ($3.statementtype) {
6338     case Statement::S_CHECK:
6339       $$ = new Statement(Statement::S_CHECK, $1, $3.templ_inst,
6340                          $3.redirectsender);
6341       break;
6342     case Statement::S_CHECK_RECEIVE:
6343       $$ = new Statement(Statement::S_CHECK_RECEIVE, $1, $3.templ_inst,
6344                          $3.fromclause, $3.redirectval, $3.redirectsender);
6345       break;
6346     case Statement::S_CHECK_GETCALL:
6347       $$ = new Statement(Statement::S_CHECK_GETCALL, $1, $3.templ_inst,
6348                          $3.fromclause, $3.redirectparam, $3.redirectsender);
6349       break;
6350     case Statement::S_CHECK_GETREPLY:
6351       $$ = new Statement(Statement::S_CHECK_GETREPLY, $1, $3.templ_inst,
6352                          $3.valuematch, $3.fromclause, $3.redirectval,
6353                          $3.redirectparam, $3.redirectsender);
6354       break;
6355     case Statement::S_CHECK_CATCH:
6356       $$ = new Statement(Statement::S_CHECK_CATCH, $1, $3.signature,
6357                          $3.templ_inst, $3.timeout, $3.fromclause,
6358                          $3.redirectval, $3.redirectsender);
6359       break;
6360     default:
6361       FATAL_ERROR("Internal error.");
6362     } // switch
6363     $$->set_location(infile, @$);
6364   }
6365 ;
6366
6367 optCheckParameter: // [418]
6368   /* empty */
6369   {
6370     $$.statementtype = Statement::S_CHECK;
6371     $$.signature = 0;
6372     $$.templ_inst = 0;
6373     $$.valuematch = 0;
6374     $$.timeout = false;
6375     $$.fromclause = 0;
6376     $$.redirectval = 0;
6377     $$.redirectparam = 0;
6378     $$.redirectsender = 0;
6379   }
6380 | '(' CheckParameter optError ')' { $$ = $2; }
6381 | '(' error ')'
6382   {
6383     $$.statementtype = Statement::S_CHECK;
6384     $$.signature = 0;
6385     $$.templ_inst = 0;
6386     $$.valuematch = 0;
6387     $$.timeout = false;
6388     $$.fromclause = 0;
6389     $$.redirectval = 0;
6390     $$.redirectparam = 0;
6391     $$.redirectsender = 0;
6392   }
6393 ;
6394
6395 CheckParameter: // 418
6396   CheckPortOpsPresent { $$ = $1; }
6397 | FromClausePresent { $$ = $1; }
6398 | RedirectPresent { $$ = $1; }
6399 ;
6400
6401 FromClausePresent: // 419
6402   FromClause
6403   {
6404     $$.statementtype = Statement::S_CHECK;
6405     $$.signature = 0;
6406     $$.templ_inst = $1;
6407     $$.valuematch = 0;
6408     $$.timeout = false;
6409     $$.fromclause = 0;
6410     $$.redirectval = 0;
6411     $$.redirectparam = 0;
6412     $$.redirectsender = 0;
6413   }
6414 | FromClause PortRedirectSymbol SenderSpec
6415   {
6416     $$.statementtype = Statement::S_CHECK;
6417     $$.signature = 0;
6418     $$.templ_inst = $1;
6419     $$.valuematch = 0;
6420     $$.timeout = false;
6421     $$.fromclause = 0;
6422     $$.redirectval = 0;
6423     $$.redirectparam = 0;
6424     $$.redirectsender = $3;
6425   }
6426 ;
6427
6428 RedirectPresent: // 420
6429   PortRedirectSymbol SenderSpec
6430   {
6431     $$.statementtype = Statement::S_CHECK;
6432     $$.signature = 0;
6433     $$.templ_inst = 0;
6434     $$.valuematch = 0;
6435     $$.timeout = false;
6436     $$.fromclause = 0;
6437     $$.redirectval = 0;
6438     $$.redirectparam = 0;
6439     $$.redirectsender = $2;
6440   }
6441 ;
6442
6443 CheckPortOpsPresent: // 421
6444   ReceiveOpKeyword PortReceiveOp
6445   {
6446     $$.statementtype = Statement::S_CHECK_RECEIVE;
6447     $$.signature = 0;
6448     $$.templ_inst = $2.templ_inst;
6449     $$.valuematch = 0;
6450     $$.timeout = false;
6451     $$.fromclause = $2.fromclause;
6452     $$.redirectval = $2.redirectval;
6453     $$.redirectparam = 0;
6454     $$.redirectsender = $2.redirectsender;
6455   }
6456 | GetCallOpKeyword PortGetCallOp
6457   {
6458     $$.statementtype = Statement::S_CHECK_GETCALL;
6459     $$.signature = 0;
6460     $$.templ_inst = $2.templ_inst;
6461     $$.valuematch = 0;
6462     $$.timeout = false;
6463     $$.fromclause = $2.fromclause;
6464     $$.redirectval = 0;
6465     $$.redirectparam = $2.redirectparam;
6466     $$.redirectsender = $2.redirectsender;
6467 }
6468 | GetReplyOpKeyword PortGetReplyOp
6469   {
6470     $$.statementtype = Statement::S_CHECK_GETREPLY;
6471     $$.signature = 0;
6472     $$.templ_inst = $2.templ_inst;
6473     $$.valuematch = $2.valuematch;
6474     $$.timeout = false;
6475     $$.fromclause = $2.fromclause;
6476     $$.redirectval = $2.redirectval;
6477     $$.redirectparam = $2.redirectparam;
6478     $$.redirectsender = $2.redirectsender;
6479 }
6480 | CatchOpKeyword PortCatchOp
6481   {
6482     $$.statementtype = Statement::S_CHECK_CATCH;
6483     $$.signature = $2.signature;
6484     $$.templ_inst = $2.templ_inst;
6485     $$.valuematch = 0;
6486     $$.timeout = $2.timeout;
6487     $$.fromclause = $2.fromclause;
6488     $$.redirectval = $2.redirectval;
6489     $$.redirectparam = 0;
6490     $$.redirectsender = $2.redirectsender;
6491   }
6492 ;
6493
6494 CatchStatement: // 422
6495   PortOrAny DotCatchOpKeyword PortCatchOp
6496   {
6497     $$ = new Statement(Statement::S_CATCH, $1, $3.signature, $3.templ_inst,
6498                        $3.timeout, $3.fromclause, $3.redirectval,
6499                        $3.redirectsender);
6500     $$->set_location(infile, @$);
6501   }
6502 ;
6503
6504 PortCatchOp: // 423
6505   optCatchOpParameter optFromClause optPortRedirect
6506   {
6507     $$.signature = $1.signature;
6508     $$.templ_inst = $1.templ_inst;
6509     $$.timeout = $1.timeout;
6510     $$.fromclause = $2;
6511     $$.redirectval = $3.redirectval;
6512     $$.redirectsender = $3.redirectsender;
6513   }
6514 ;
6515
6516 optCatchOpParameter: // [425]
6517   /* empty */
6518   {
6519     $$.signature = 0;
6520     $$.templ_inst = 0;
6521     $$.timeout = false;
6522   }
6523 | '(' CatchOpParameter optError ')' { $$ = $2; }
6524 | '(' error ')'
6525   {
6526     $$.signature = 0;
6527     $$.templ_inst = 0;
6528     $$.timeout = false;
6529   }
6530 ;
6531
6532 CatchOpParameter: // 425
6533   Signature optError ',' optError TemplateInstance
6534   {
6535     $$.signature = $1;
6536     $$.templ_inst = $5;
6537     $$.timeout = false;
6538   }
6539 | TimeoutKeyword
6540   {
6541     $$.signature = 0;
6542     $$.templ_inst = 0;
6543     $$.timeout = true;
6544   }
6545 ;
6546
6547 ClearStatement: // 426
6548   PortOrAll DotClearOpKeyword
6549   {
6550     $$ = new Statement(Statement::S_CLEAR, $1);
6551     $$->set_location(infile, @$);
6552   }
6553 ;
6554
6555 PortOrAll: // 427
6556   Port { $$ = $1; }
6557 | AllKeyword PortKeyword { $$ = 0; }
6558 ;
6559
6560 StartStatement: // 430
6561 /*  Port DotPortStartKeyword -- covered by StartTimerStatement */
6562   AllKeyword PortKeyword DotStartKeyword
6563   {
6564     $$=new Statement(Statement::S_START_PORT, (Ttcn::Reference*)0);
6565     $$->set_location(infile, @$);
6566   }
6567 ;
6568
6569 StopStatement: // 432
6570 /*  Port DotPortStopKeyword -- covered by StopTimerStatement */
6571   AllKeyword PortKeyword DotStopKeyword
6572   {
6573     $$=new Statement(Statement::S_STOP_PORT, (Ttcn::Reference*)0);
6574     $$->set_location(infile, @$);
6575   }
6576 ;
6577
6578 HaltStatement: // 435
6579   PortOrAll DotHaltKeyword
6580   {
6581     $$ = new Statement(Statement::S_HALT, $1);
6582     $$->set_location(infile, @$);
6583   }
6584 ;
6585
6586 /* A.1.6.2.5 Timer operations */
6587
6588 TimerStatements: // 439
6589   StartTimerStatement { $$ = $1; }
6590 | StopTimerStatement { $$ = $1; }
6591 | TimeoutStatement { $$ = $1; }
6592 ;
6593
6594 TimerOps: // 440
6595   ReadTimerOp { $$ = $1; }
6596 | RunningTimerOp { $$ = $1; }
6597 ;
6598
6599 StartTimerStatement: // 441
6600   VariableRef DotStartKeyword
6601   {
6602     $$ = new Statement(Statement::S_START_UNDEF, $1, (Value*)0);
6603     $$->set_location(infile, @$);
6604   }
6605 | VariableRef DotStartKeyword '(' Expression optError ')'
6606   {
6607     $$ = new Statement(Statement::S_START_UNDEF, $1, $4);
6608     $$->set_location(infile, @$);
6609   }
6610 | VariableRef DotStartKeyword '(' error ')'
6611   {
6612     Value *v = new Value(Value::V_ERROR);
6613     v->set_location(infile, @4);
6614     $$ = new Statement(Statement::S_START_UNDEF, $1, v);
6615     $$->set_location(infile, @$);
6616   }
6617 ;
6618
6619 StopTimerStatement: // 442
6620   TimerRef DotStopKeyword
6621   {
6622     $$ = new Statement(Statement::S_STOP_UNDEF, $1, (Value*)0);
6623     $$->set_location(infile, @$);
6624   }
6625 | AllKeyword TimerKeyword DotStopKeyword
6626   {
6627     $$ = new Statement(Statement::S_STOP_TIMER, (Ttcn::Reference*)0);
6628     $$->set_location(infile, @$);
6629   }
6630 ;
6631
6632 /* no separate rule, folded into StopTimerStatement
6633 TimerRefOrAll: // 443
6634   TimerRef
6635 | AllKeyword TimerKeyword
6636 ;
6637 */
6638
6639 ReadTimerOp: // 444
6640   TimerRef DotReadKeyword
6641   {
6642     $$ = new Value(Value::OPTYPE_TMR_READ, $1);
6643     $$->set_location(infile, @$);
6644   }
6645 ;
6646
6647 RunningTimerOp: // 446
6648   TimerRef DotRunningKeyword
6649   {
6650     $$ = new Value(Value::OPTYPE_UNDEF_RUNNING, $1);
6651     $$->set_location(infile, @$);
6652   }
6653 | AnyKeyword TimerKeyword DotRunningKeyword
6654   {
6655     $$ = new Value(Value::OPTYPE_TMR_RUNNING_ANY);
6656     $$->set_location(infile, @$);
6657   }
6658 ;
6659
6660 TimeoutStatement: // 447
6661   TimerRefOrAny DotTimeoutKeyword
6662   {
6663     $$ = new Statement(Statement::S_TIMEOUT, $1);
6664     $$->set_location(infile, @$);
6665   }
6666 ;
6667
6668 TimerRefOrAny: // 448
6669   TimerRef { $$ = $1; }
6670 | AnyKeyword TimerKeyword { $$ = 0; }
6671 ;
6672
6673 /* A.1.6.3 Type */
6674
6675 Type: // 450
6676   PredefinedType
6677   {
6678     $$ = new Type($1);
6679     $$->set_location(infile, @$);
6680   }
6681 | AnyTypeKeyword /* a predefined type with special treatment */
6682   {
6683     anytype_access = true;
6684     Identifier *id = new Identifier(Identifier::ID_TTCN, string("anytype"));
6685     Ttcn::Reference *ref = new Ttcn::Reference(id);
6686     ref->set_location(infile, @1);
6687     $$ = new Type(Type::T_REFD, ref);
6688   }
6689 | ReferencedType { $$ = $1; }
6690
6691 ;
6692
6693 PredefinedType: // 451, but see below
6694   BitStringKeyword { $$ = Type::T_BSTR; }
6695 | BooleanKeyword { $$ = Type::T_BOOL; }
6696 | CharStringKeyword { $$ = Type::T_CSTR; }
6697 | UniversalCharString { $$ = Type::T_USTR; }
6698 | CharKeyword // not in the standard anymore
6699   {
6700     Location loc(infile, @$);
6701     loc.warning("Obsolete type `char' was substituted with `charstring'");
6702     $$ = Type::T_CSTR;
6703   }
6704 | UniversalChar // not in the standard anymore
6705   {
6706     Location loc(infile, @$);
6707     loc.warning("Obsolete type `universal char' was substituted with "
6708                 "`universal charstring'");
6709     $$ = Type::T_USTR;
6710   }
6711 | IntegerKeyword { $$ = Type::T_INT; }
6712 | OctetStringKeyword { $$ = Type::T_OSTR; }
6713 | HexStringKeyword { $$ = Type::T_HSTR; }
6714 | VerdictTypeKeyword { $$ = Type::T_VERDICT; }
6715 | FloatKeyword { $$ = Type::T_REAL; }
6716 | AddressKeyword { $$ = Type::T_ADDRESS; }
6717 | DefaultKeyword { $$ = Type::T_DEFAULT; }
6718 | ObjectIdentifierKeyword { $$ = Type::T_OID; }
6719 /*
6720  * AnyTypeKeyword is not part of PredefinedType (this differs from the BNF
6721  * in the TTCN-3 standard).
6722  * PredefinedType is used in two contexts:
6723  * - as a RHS for Type, above (where AnyTypeKeyword needs special treatment,
6724  *   and it's easier to appear as an alternative to PredefinedType)
6725  * - as field name for the anytype (where anytype is not permitted)
6726  */
6727 ;
6728
6729 UniversalCharString: // 463
6730   UniversalKeyword CharStringKeyword
6731 ;
6732
6733 UniversalChar:
6734   UniversalKeyword CharKeyword
6735 ;
6736
6737 ReferencedType: // 465
6738   Reference
6739   {
6740     if ($1.is_ref) $$ = new Type(Type::T_REFD, $1.ref);
6741     else {
6742       Ttcn::Reference *ref = new Ttcn::Reference($1.id);
6743       ref->set_location(infile, @1);
6744       $$ = new Type(Type::T_REFD, ref);
6745     }
6746     $$->set_location(infile, @$);
6747   }
6748 | FunctionInstance optExtendedFieldReference
6749   /* covers all parameterized type references */
6750   {
6751     Location loc(infile, @1);
6752     loc.error("Reference to parameterized type is not currently supported");
6753     delete $1;
6754     for (size_t i = 0; i < $2.nElements; i++) delete $2.elements[i];
6755     Free($2.elements);
6756     $$ = new Type(Type::T_ERROR);
6757     $$->set_location(infile, @$);
6758   }
6759 ;
6760
6761 /*
6762 TypeReference: // 466
6763   IDentifier
6764 | IDentifier TypeActualParList
6765 ;
6766 */
6767
6768 TypeActualParList: // -> 202 784 "Advanced Parameterization"
6769   '(' seqTypeActualPar optError ')'
6770 | '(' error ')'
6771 ;
6772
6773 seqTypeActualPar: // -> 202 784 "Advanced Parameterization"
6774   optError TypeActualPar
6775 | seqTypeActualPar optError ',' optError TypeActualPar
6776 | seqTypeActualPar optError ',' error
6777 ;
6778
6779 TypeActualPar: // -> 202 784 "Advanced Parameterization"
6780   Expression { delete $1; }
6781 ;
6782
6783 optArrayDef: // [467]
6784   /* empty */
6785   {
6786     $$.nElements = 0;
6787     $$.elements = 0;
6788   }
6789 | optArrayDef ArrayIndex
6790   {
6791     $$.nElements = $1.nElements + 1;
6792     $$.elements = (ArrayDimension**)
6793       Realloc($1.elements, $$.nElements * sizeof(*$$.elements));
6794     $$.elements[$1.nElements] = $2;
6795   }
6796 ;
6797
6798 ArrayIndex:
6799   '[' ArrayBounds ']'
6800   {
6801     $$ = new ArrayDimension($2);
6802     $$->set_location(infile, @$);
6803   }
6804 | '[' ArrayBounds DotDot ArrayBounds ']'
6805   {
6806     $$ = new ArrayDimension($2, $4);
6807     $$->set_location(infile, @$);
6808   }
6809 | '[' error ']'
6810   {
6811     Value *v = new Value(Value::V_ERROR);
6812     v->set_location(infile, @2);
6813     $$ = new ArrayDimension(v);
6814     $$->set_location(infile, @$);
6815   }
6816 ;
6817
6818 ArrayBounds: // 468
6819   Expression { $$ = $1; }
6820 ;
6821
6822 /* A.1.6.4 Value */
6823
6824 Value: // 469
6825   PredefinedValue { $$ = $1; }
6826 | ReferencedValue { $$ = $1; }
6827 ;
6828
6829 PredefinedValue: // 470
6830   BitStringValue { $$ = $1; }
6831 | BooleanValue { $$ = $1; }
6832 | CharStringValue { $$ = $1; }
6833 | IntegerValue { $$ = $1; }
6834 | OctetStringValue { $$ = $1; }
6835 | HexStringValue { $$ = $1; }
6836 | VerdictValue { $$ = $1; }
6837 /*  | EnumeratedValue -- covered by ReferencedValue */
6838 | FloatOrSpecialFloatValue
6839   {
6840     $$ = new Value(Value::V_REAL, $1);
6841     $$->set_location(infile, @$);
6842   }
6843 | AddressValue { $$ = $1; }
6844 | OmitValue { $$ = $1; }
6845 | NullValue
6846   {
6847     $$ = new Value(Value::V_NULL);
6848     $$->set_location(infile, @$);
6849   }
6850 | MacroValue
6851   {
6852     $$ = new Value(Value::V_MACRO, $1);
6853     $$->set_location(infile, @$);
6854   }
6855 | ObjectIdentifierValue { $$ = $1; }
6856 | TOK_errval
6857   {
6858     $$=new Value(Value::V_ERROR);
6859     $$->set_location(infile, @$);
6860   }
6861 ;
6862
6863 BitStringValue: // 471
6864   Bstring
6865   {
6866     $$ = new Value(Value::V_BSTR, $1);
6867     $$->set_location(infile, @$);
6868   }
6869 ;
6870
6871 BooleanValue: // 472
6872   TrueKeyword
6873   {
6874     $$ = new Value(Value::V_BOOL, true);
6875     $$->set_location(infile, @$);
6876   }
6877 | FalseKeyword
6878   {
6879     $$ = new Value(Value::V_BOOL, false);
6880     $$->set_location(infile, @$);
6881   }
6882 ;
6883
6884 /* TTCN-3 core language V4.2.1 */
6885 FloatOrSpecialFloatValue:
6886   FloatValue
6887   {
6888     $$ = $1;
6889   }
6890 | InfinityKeyword
6891   {
6892     $$ = REAL_INFINITY;
6893   }
6894 | NaNKeyword
6895   {
6896     $$ = REAL_NAN;
6897   }
6898 ;
6899
6900 IntegerValue: // 473
6901   Number
6902   {
6903     $$ = new Value(Value::V_INT, $1);
6904     $$->set_location(infile, @$);
6905   }
6906 ;
6907
6908 OctetStringValue: // 474
6909   Ostring
6910   {
6911     $$ = new Value(Value::V_OSTR, $1);
6912     $$->set_location(infile, @$);
6913   }
6914 ;
6915
6916 HexStringValue: // 475
6917   Hstring
6918   {
6919     $$ = new Value(Value::V_HSTR, $1);
6920     $$->set_location(infile, @$);
6921   }
6922 ;
6923
6924 VerdictValue: // 476 VerdictTypeValue
6925   NoneKeyword
6926   {
6927     $$ = new Value(Value::V_VERDICT, Value::Verdict_NONE);
6928     $$->set_location(infile, @$);
6929   }
6930 | PassKeyword
6931   {
6932     $$ = new Value(Value::V_VERDICT, Value::Verdict_PASS);
6933     $$->set_location(infile, @$);
6934   }
6935 | InconcKeyword
6936   {
6937     $$ = new Value(Value::V_VERDICT, Value::Verdict_INCONC);
6938     $$->set_location(infile, @$);
6939   }
6940 | FailKeyword
6941   {
6942     $$ = new Value(Value::V_VERDICT, Value::Verdict_FAIL);
6943     $$->set_location(infile, @$);
6944   }
6945 | ErrorKeyword
6946   {
6947     $$ = new Value(Value::V_VERDICT, Value::Verdict_ERROR);
6948     $$->set_location(infile, @$);
6949   }
6950 ;
6951
6952 CharStringValue: // 478
6953   CstringList
6954   {
6955     if ($1->is_cstr()) $$ = new Value(Value::V_CSTR, $1);
6956     else {
6957       $$ = new Value(Value::V_USTR, new ustring(*$1));
6958       delete $1;
6959     }
6960     $$->set_location(infile, @$);
6961   }
6962 | Quadruple
6963   {
6964     $$ = new Value(Value::V_USTR, new ustring(*$1));
6965     delete $1;
6966     $$->set_location(infile, @$);
6967   }
6968 ;
6969
6970 CstringList:
6971   Cstring
6972   {
6973     Location loc(infile, @1);
6974     $$ = parse_charstring_value($1, loc);
6975     Free($1);
6976   }
6977 ;
6978
6979 Quadruple: // 479
6980   CharKeyword '(' optError Group optError ',' optError Plane optError ','
6981   optError Row optError ',' optError Cell optError ')'
6982   { $$ = new ustring($4, $8, $12, $16); }
6983 | CharKeyword '(' error ')' { $$ = new ustring; }
6984 ;
6985
6986 Group: // 481
6987   Number
6988   {
6989     if (*$1 < 0 || *$1 > 127) {
6990       Location loc(infile, @1);
6991       loc.error("The first number of quadruple (group) must be within the "
6992         "range 0 .. 127 instead of %s", $1->t_str().c_str());
6993       $$ = *$1 < 0 ? 0 : 127;
6994     } else {
6995         $$ = $1->get_val();
6996     }
6997     delete $1;
6998   }
6999 ;
7000
7001 Plane: // 482
7002   Number
7003   {
7004     if (*$1 < 0 || *$1 > 255) {
7005       Location loc(infile, @1);
7006       loc.error("The second number of quadruple (plane) must be within the "
7007         "range 0 .. 255 instead of %s", $1->t_str().c_str());
7008       $$ = *$1 < 0 ? 0 : 255;
7009     } else {
7010         $$ = $1->get_val();
7011         }
7012     delete $1;
7013   }
7014 ;
7015
7016 Row: // 483
7017   Number
7018   {
7019     if (*$1 < 0 || *$1 > 255) {
7020       Location loc(infile, @1);
7021       loc.error("The third number of quadruple (row) must be within the "
7022         "range 0 .. 255 instead of %s", $1->t_str().c_str());
7023       $$ = *$1 < 0 ? 0 : 255;
7024     } else {
7025         $$ = $1->get_val();
7026         }
7027     delete $1;
7028   }
7029 ;
7030
7031 Cell: // 484
7032   Number
7033   {
7034     if (*$1 < 0 || *$1 > 255) {
7035       Location loc(infile, @1);
7036       loc.error("The fourth number of quadruple (cell) must be within the "
7037         "range 0 .. 255 instead of %s", $1->t_str().c_str());
7038       $$ = *$1 < 0 ? 0 : 255;
7039     } else {
7040         $$ = $1->get_val();
7041     }
7042     delete $1;
7043   }
7044 ;
7045
7046 FreeText: // 509
7047   Cstring { $$ = $1; }
7048 | FreeText Cstring
7049   {
7050     $$ = mputstr($1, $2);
7051     Free($2);
7052   }
7053 ;
7054
7055 AddressValue: // 510
7056   NullKeyword
7057   {
7058     $$ = new Value(Value::V_TTCN3_NULL);
7059     $$->set_location(infile, @$);
7060   }
7061 ;
7062
7063 OmitValue: // 511
7064   OmitKeyword
7065   {
7066     $$ = new Value(Value::V_OMIT);
7067     $$->set_location(infile, @$);
7068   }
7069 ;
7070
7071 ReferencedValue: // 489
7072   Reference
7073   {
7074     if ($1.is_ref) $$ = new Value(Value::V_REFD, $1.ref);
7075     else $$ = new Value(Value::V_UNDEF_LOWERID, $1.id);
7076     $$->set_location(infile, @$);
7077   }
7078
7079 Reference: // 490 ValueReference
7080   IDentifier
7081   {
7082     $$.is_ref = false;
7083     $$.id = $1;
7084   }
7085 | IDentifier '.' PredefOrIdentifier optExtendedFieldReference
7086   {
7087     $$.is_ref = true;
7088     $$.ref = new Ttcn::Reference($1);
7089     FieldOrArrayRef *fieldref = new FieldOrArrayRef($3);
7090     fieldref->set_location(infile, @3);
7091     $$.ref->add(fieldref);
7092     for (size_t i = 0; i < $4.nElements; i++) $$.ref->add($4.elements[i]);
7093     Free($4.elements);
7094     $$.ref->set_location(infile, @$);
7095   }
7096 | IDentifier ArrayOrBitRef optExtendedFieldReference
7097   {
7098     $$.is_ref = true;
7099     $$.ref = new Ttcn::Reference($1);
7100     $$.ref->add($2);
7101     for (size_t i = 0; i < $3.nElements; i++) $$.ref->add($3.elements[i]);
7102     Free($3.elements);
7103     $$.ref->set_location(infile, @$);
7104   }
7105 | IDentifier '[' NotUsedSymbol ']'
7106 {
7107   $$.is_ref = true;
7108   $$.ref = new Ttcn::Reference($1);
7109   Value* novalue = new Value(Value::V_NOTUSED);
7110   novalue->set_location(infile, @3);
7111   $$.ref->add(new FieldOrArrayRef(novalue));
7112   $$.ref->set_location(infile, @$);
7113 }
7114 | IDentifier '.' ObjectIdentifierValue '.' IDentifier
7115   optExtendedFieldReference
7116   {
7117     $$.is_ref = true;
7118     $$.ref = new Ttcn::Reference($1, $5);
7119     delete $3;
7120     for (size_t i = 0; i < $6.nElements; i++) $$.ref->add($6.elements[i]);
7121     Free($6.elements);
7122     $$.ref->set_location(infile, @$);
7123   }
7124 ;
7125
7126 /* A.1.6.5 Parameterization */
7127
7128 optLazyEval:
7129   /* empty */ { $$ = false; }
7130 | TitanSpecificLazyKeyword { $$ = true; }
7131 ;
7132
7133 FormalValuePar: // 516
7134   optLazyEval Type IDentifier optParDefaultValue
7135   {
7136     $$ = new FormalPar(Common::Assignment::A_PAR_VAL, $2, $3, $4, $1);
7137     $$->set_location(infile, @$);
7138   }
7139 | InParKeyword optLazyEval Type IDentifier optParDefaultValue
7140   {
7141     $$ = new FormalPar(Common::Assignment::A_PAR_VAL_IN, $3, $4, $5, $2);
7142     $$->set_location(infile, @$);
7143   }
7144 | InOutParKeyword Type IDentifier optParDefaultValue
7145   {
7146     $$ = new FormalPar(Common::Assignment::A_PAR_VAL_INOUT, $2, $3, $4);
7147     $$->set_location(infile, @$);
7148   }
7149 | OutParKeyword Type IDentifier optParDefaultValue
7150   {
7151     $$ = new FormalPar(Common::Assignment::A_PAR_VAL_OUT, $2, $3, $4);
7152     $$->set_location(infile, @$);
7153   }
7154 ;
7155
7156 /*
7157 FormalPortPar: // 518
7158   IDentifier IDentifier
7159 | InOutParKeyword IDentifier IDentifier
7160 ;
7161 */
7162
7163 FormalTimerPar: // 520
7164   TimerKeyword IDentifier optParDefaultValue
7165   {
7166     $$ = new FormalPar(Common::Assignment::A_PAR_TIMER, $2, $3);
7167     $$->set_location(infile, @$);
7168   }
7169 | InOutParKeyword TimerKeyword IDentifier optParDefaultValue
7170   {
7171     $$ = new FormalPar(Common::Assignment::A_PAR_TIMER, $3, $4);
7172     $$->set_location(infile, @$);
7173   }
7174 ;
7175
7176 FormalTemplatePar: // 522
7177   TemplateOptRestricted optLazyEval Type IDentifier optParDefaultValue
7178   {
7179     $$ = new FormalPar(Common::Assignment::A_PAR_TEMPL_IN, $1, $3, $4, $5, $2);
7180     $$->set_location(infile, @$);
7181   }
7182 | InParKeyword TemplateOptRestricted optLazyEval Type IDentifier optParDefaultValue
7183   {
7184     $$ = new FormalPar(Common::Assignment::A_PAR_TEMPL_IN, $2, $4, $5, $6, $3);
7185     $$->set_location(infile, @$);
7186   }
7187 | InOutParKeyword TemplateOptRestricted Type IDentifier optParDefaultValue
7188   {
7189     $$ = new FormalPar(Common::Assignment::A_PAR_TEMPL_INOUT, $2, $3, $4, $5);
7190     $$->set_location(infile, @$);
7191   }
7192 | OutParKeyword TemplateOptRestricted Type IDentifier optParDefaultValue
7193   {
7194     $$ = new FormalPar(Common::Assignment::A_PAR_TEMPL_OUT, $2, $3, $4, $5);
7195     $$->set_location(infile, @$);
7196   }
7197 ;
7198
7199 /* template with optional restriction */
7200 TemplateOptRestricted:
7201   TemplateKeyword optTemplateRestriction
7202   {
7203     $$ = $2;
7204   }
7205 | OmitKeyword
7206   {
7207     $$ = TR_OMIT;
7208   }
7209 ;
7210
7211 optTemplateRestriction:
7212   /* none */ { $$ = TR_NONE; }
7213 | TemplateRestriction { $$ = $1; }
7214
7215 TemplateRestriction:
7216   '(' OmitKeyword ')'    { $$ = TR_OMIT; }
7217 | '(' ValueKeyword ')'   { $$ = TR_VALUE; }
7218 | '(' PresentKeyword ')'   { $$ = TR_PRESENT; }
7219 ;
7220
7221 optParDefaultValue:
7222   /* empty */ { $$ = NULL; }
7223 | AssignmentChar TemplateInstance { $$ = $2; }
7224 | AssignmentChar NotUsedSymbol
7225   {
7226     Template *t = new Template(Template::TEMPLATE_NOTUSED);
7227     t->set_location(infile, @$);
7228     $$ = new TemplateInstance(0, 0, t);
7229     $$->set_location(infile, @$);
7230   }
7231 ;
7232
7233 /* A.1.6.6 With statement */
7234
7235 optWithStatement: // [526]
7236   /* empty */ { $$ = NULL; }
7237 | WithStatement { $$ = $1; }
7238 ;
7239
7240 optWithStatementAndSemiColon:
7241   /* empty */ { $$ = NULL; }
7242 | WithStatement { $$ = $1; }
7243 | ';' { $$ = NULL; }
7244 | WithStatement ';' { $$ = $1; }
7245 ;
7246
7247 WithStatement: // 526
7248   WithKeyword WithAttribList { $$ = $2; }
7249 ;
7250
7251 WithAttribList: // 528
7252   '{' MultiWithAttrib optError '}' { $$ = $2; }
7253 | '{' error '}' { $$ = NULL; }
7254 ;
7255
7256 MultiWithAttrib: // 529
7257   optError SingleWithAttrib optSemiColon
7258   {
7259     $$ = new MultiWithAttrib;
7260     $$->set_location(infile, @$);
7261     $$->add_element($2);
7262   }
7263 | MultiWithAttrib optError SingleWithAttrib optSemiColon
7264   {
7265     $$ = $1;
7266     $$->add_element($3);
7267   }
7268 ;
7269
7270 SingleWithAttrib: // 530
7271   AttribKeyword optOverrideKeyword optAttribQualifier AttribSpec
7272   {
7273     $$ = new SingleWithAttrib($1,$2,$3,$4);
7274     $$->set_location(infile, @$);
7275   }
7276 ;
7277
7278 AttribKeyword: // 531
7279   EncodeKeyword { $$ = SingleWithAttrib::AT_ENCODE; }
7280 | VariantKeyword { $$ = SingleWithAttrib::AT_VARIANT; }
7281 | DisplayKeyword { $$ = SingleWithAttrib::AT_DISPLAY; }
7282 | ExtensionKeyword { $$ = SingleWithAttrib::AT_EXTENSION; }
7283 | OptionalKeyword { $$ = SingleWithAttrib::AT_OPTIONAL; }
7284 | IDentifier
7285   {
7286     /* workaround to get rid of ErroneousKeyword which would clash with
7287      * existing TTCN-3 source code */
7288     if ($1->get_ttcnname()=="erroneous") $$ = SingleWithAttrib::AT_ERRONEOUS;
7289     else {
7290       Location loc(infile, @1);
7291       loc.error("Invalid attribute. Valid attributes are: "
7292                 "`encode', `variant' , `display' , `extension', `optional' and `erroneous'");
7293       if ($1->get_ttcnname()=="titan")
7294         loc.note("\n"
7295           " ________    _____   ________     ____        __      _  \n"
7296           "(___  ___)  (_   _) (___  ___)   (    )      /  \\    / ) \n"
7297           "    ) )       | |       ) )      / /\\ \\     / /\\ \\  / /  \n"
7298           "   ( (        | |      ( (      ( (__) )    ) ) ) ) ) )  \n"
7299           "    ) )       | |       ) )      )    (    ( ( ( ( ( (   \n"
7300           "   ( (       _| |__    ( (      /  /\\  \\   / /  \\ \\/ /   \n"
7301           "   /__\\     /_____(    /__\\    /__(  )__\\ (_/    \\__/    \n");
7302       $$ = SingleWithAttrib::AT_INVALID;
7303     }
7304     delete $1;
7305   }
7306 ;
7307
7308 optOverrideKeyword: // [536]
7309   /* empty */ { $$ = false; }
7310 | OverrideKeyword { $$ = true; }
7311 ;
7312
7313 optAttribQualifier: // [537]
7314   /* empty */ { $$ = NULL; }
7315 | '(' DefOrFieldRefList optError ')' { $$ = $2; }
7316 | '(' error ')' { $$ = NULL; }
7317 ;
7318
7319 DefOrFieldRefList: // 538
7320   optError DefOrFieldRef
7321   {
7322     $$ = new Qualifiers();
7323     if ($2) $$->add_qualifier($2);
7324   }
7325 | DefOrFieldRefList optError ',' optError DefOrFieldRef
7326   {
7327     $$ = $1;
7328     if ($5) $$->add_qualifier($5);
7329   }
7330 | DefOrFieldRefList optError ',' error { $$ = $1; }
7331 ;
7332
7333 ArrayOrBitRefOrDash:
7334 ArrayOrBitRef  { $$ = $1; }
7335 | '[' NotUsedSymbol ']'
7336 {
7337   Value* novalue = new Value(Value::V_NOTUSED);
7338   novalue->set_location(infile, @2);
7339   $$ = new FieldOrArrayRef(novalue);
7340   $$->set_location(infile, @$);
7341 }
7342
7343 DefOrFieldRef: // 539
7344   IDentifier
7345   {
7346     $$ = new Qualifier();
7347     $$->add(new FieldOrArrayRef($1));
7348     $$->set_location(infile, @1);
7349   }
7350 | IDentifier '.' IDentifier optExtendedFieldReference
7351 {
7352   $$ = new Qualifier();
7353   $$->add(new FieldOrArrayRef($1));
7354   $$->add(new FieldOrArrayRef($3));
7355   for(size_t i=0; i<$4.nElements; i++) {
7356     $$->add($4.elements[i]);
7357   }
7358   Free($4.elements);
7359   $$->set_location(infile, @$);
7360 }
7361 | IDentifier ArrayOrBitRefOrDash optExtendedFieldReference
7362 {
7363   $$ = new Qualifier();
7364   $$->add(new FieldOrArrayRef($1));
7365   $$->add($2);
7366   for(size_t i=0; i<$3.nElements; i++) {
7367     $$->add($3.elements[i]);
7368   }
7369   Free($3.elements);
7370   $$->set_location(infile, @$);
7371 }
7372 | ArrayOrBitRefOrDash optExtendedFieldReference
7373 {
7374   $$ = new Qualifier();
7375   $$->add($1);
7376   for(size_t i=0; i<$2.nElements; i++) {
7377     $$->add($2.elements[i]);
7378   }
7379   Free($2.elements);
7380   $$->set_location(infile, @$);
7381 }
7382 | AllRef
7383   {
7384     Location loc(infile, @$);
7385     loc.error("Reference to multiple definitions in attribute qualifiers is "
7386       "not currently supported");
7387     $$ = 0;
7388   }
7389 ;
7390
7391 AllRef: // 541
7392   GroupKeyword AllKeyword
7393 | GroupKeyword AllKeyword ExceptKeyword '{' GroupRefList optError '}'
7394 | TypeDefKeyword AllKeyword
7395 | TypeDefKeyword AllKeyword ExceptKeyword '{' TypeRefList optError '}'
7396 | TemplateKeyword AllKeyword
7397 | TemplateKeyword AllKeyword ExceptKeyword '{' TemplateRefList optError '}'
7398 | ConstKeyword AllKeyword
7399 | ConstKeyword AllKeyword ExceptKeyword '{' ConstRefList optError '}'
7400 | AltstepKeyword AllKeyword
7401 | AltstepKeyword AllKeyword ExceptKeyword '{' AltstepRefList optError '}'
7402 | TestcaseKeyword AllKeyword
7403 | TestcaseKeyword AllKeyword ExceptKeyword '{' TestcaseRefList optError '}'
7404 | FunctionKeyword AllKeyword
7405 | FunctionKeyword AllKeyword ExceptKeyword '{' FunctionRefList optError '}'
7406 | SignatureKeyword AllKeyword
7407 | SignatureKeyword AllKeyword ExceptKeyword '{' SignatureRefList optError '}'
7408 | ModuleParKeyword AllKeyword
7409 | ModuleParKeyword AllKeyword ExceptKeyword '{' ModuleParRefList optError '}'
7410 ;
7411
7412 AttribSpec: // 542
7413   FreeText
7414   {
7415     $$ = new AttributeSpec(string($1));
7416     $$->set_location(infile, @$);
7417     Free($1);
7418   }
7419 ;
7420
7421 /* A.1.6.7 Behaviour statements */
7422
7423 BehaviourStatements: // 543
7424   TestcaseInstance
7425   {
7426     if ($1.ref_pard) $$ = new Statement(Statement::S_TESTCASE_INSTANCE,
7427       $1.ref_pard, $1.value);
7428     else if($1.derefered_value) {
7429       $$ = new Statement(Statement::S_TESTCASE_INSTANCE_REFD,
7430         $1.derefered_value, $1.ap_list->steal_tis(), $1. value);
7431       delete $1.ap_list;
7432     }
7433     else $$ = new Statement(Statement::S_ERROR);
7434     $$->set_location(infile, @$);
7435   }
7436 | FunctionInstance
7437   {
7438     $$ = new Statement(Statement::S_UNKNOWN_INSTANCE, $1);
7439     $$->set_location(infile, @$);
7440   }
7441 | ApplyOp
7442   {
7443     $$ = new Statement(Statement::S_UNKNOWN_INVOKED, $1.value, $1.ap_list);
7444     $$->set_location(infile, @$);
7445   }
7446 | ReturnStatement { $$ = $1; }
7447 | AltConstruct { $$ = $1; }
7448 | InterleavedConstruct { $$ = $1; }
7449 | LabelStatement { $$ = $1; }
7450 | GotoStatement { $$=$1; }
7451 | RepeatStatement { $$ = $1; }
7452 | BreakStatement { $$ = $1; }
7453 | ContinueStatement { $$ = $1; }
7454 | DeactivateStatement { $$ = $1; }
7455 /* | AltstepInstance -- covered by FunctionInstance */
7456 | ActivateOp
7457   {
7458     if ($1.ref_pard) $$ = new Statement(Statement::S_ACTIVATE, $1.ref_pard);
7459     else if($1.derefered_value) $$ = new Statement(Statement::S_ACTIVATE_REFD,
7460       $1.derefered_value, new ParsedActualParameters($1.ap_list));
7461     else $$ = new Statement(Statement::S_ERROR);
7462     $$->set_location(infile, @$);
7463   }
7464 ;
7465
7466 VerdictStatements: // 544
7467   SetLocalVerdict { $$ = $1; }
7468 ;
7469
7470 VerdictOps: // 545
7471   GetLocalVerdict { $$ = $1; }
7472 ;
7473
7474 SetLocalVerdict: // 546
7475   SetVerdictKeyword '(' Expression optError ',' LogItemList optError ')'
7476   {
7477     $$=new Statement(Statement::S_SETVERDICT, $3, $6);
7478     $$->set_location(infile, @$);
7479   }
7480 | SetVerdictKeyword '(' Expression optError ')'
7481   {
7482     $$=new Statement(Statement::S_SETVERDICT, $3, (LogArguments*)0);
7483     $$->set_location(infile, @$);
7484   }
7485 | SetVerdictKeyword '(' error ')'
7486   {
7487     Value *v = new Value(Value::V_ERROR);
7488     v->set_location(infile, @3);
7489     $$ = new Statement(Statement::S_SETVERDICT, v);
7490     $$->set_location(infile, @$);
7491   }
7492 ;
7493
7494 GetLocalVerdict: // 548
7495   GetVerdictKeyword
7496   {
7497     $$=new Value(Value::OPTYPE_GETVERDICT);
7498     $$->set_location(infile, @$);
7499   }
7500 ;
7501
7502 SUTStatements: // 549
7503   ActionKeyword '(' ')'
7504   {
7505     $$=new Statement(Statement::S_ACTION, (LogArguments*)0);
7506     $$->set_location(infile, @$);
7507   }
7508 | ActionKeyword '(' LogItemList optError ')'
7509   {
7510     $$=new Statement(Statement::S_ACTION, $3);
7511     $$->set_location(infile, @$);
7512   }
7513 | ActionKeyword '(' error ')'
7514   {
7515     $$=new Statement(Statement::S_ACTION, new LogArguments());
7516     $$->set_location(infile, @$);
7517   }
7518 ;
7519
7520 StopExecutionStatement:
7521   StopKeyword
7522   {
7523     $$=new Statement(Statement::S_STOP_EXEC);
7524     $$->set_location(infile, @$);
7525   }
7526 ;
7527
7528 StopTestcaseStatement:
7529   TestcaseKeyword DotStopKeyword
7530   {
7531     $$ = new Statement(Statement::S_STOP_TESTCASE, (LogArguments*)0);
7532     $$->set_location(infile, @$);
7533   }
7534 | TestcaseKeyword DotStopKeyword '(' LogItemList optError ')'
7535   {
7536     $$ = new Statement(Statement::S_STOP_TESTCASE, $4);
7537     $$->set_location(infile, @$);
7538   }
7539 ;
7540
7541 ReturnStatement: // 552
7542   ReturnKeyword
7543   {
7544     $$=new Statement(Statement::S_RETURN, (Template*)0);
7545     $$->set_location(infile, @$);
7546   }
7547 | ReturnKeyword TemplateBody
7548   {
7549     $$=new Statement(Statement::S_RETURN, $2);
7550     $$->set_location(infile, @$);
7551   }
7552 ;
7553
7554 AltConstruct: // 553
7555   AltKeyword '{' AltGuardList optError '}'
7556   {
7557     $$=new Statement(Statement::S_ALT, $3);
7558     $$->set_location(infile, @$);
7559   }
7560 | AltKeyword '{' error '}'
7561   {
7562     $$=new Statement(Statement::S_ALT, new AltGuards());
7563     $$->set_location(infile, @$);
7564   }
7565 ;
7566
7567 AltGuardList: // 555
7568   optError AltGuard
7569   {
7570     $$ = new AltGuards;
7571     $$->add_ag($2);
7572   }
7573 | AltGuardList optError AltGuard
7574   {
7575     $$ = $1;
7576     $$->add_ag($3);
7577   }
7578 ;
7579
7580 AltGuard:
7581   GuardStatement { $$ = $1; }
7582 | ElseStatement { $$ = $1; }
7583 ;
7584
7585 GuardStatement: // 556
7586   AltGuardChar AltstepInstance optSemiColon
7587   {
7588     $$=new AltGuard($1, $2, 0);
7589     $$->set_location(infile, @$);
7590   }
7591 | AltGuardChar ApplyOp optSemiColon
7592   {
7593     $$=new AltGuard($1, $2.value, $2.ap_list->steal_tis(), 0);
7594     $$->set_location(infile, @$);
7595     delete $2.ap_list;
7596   }
7597 | AltGuardChar AltstepInstance optSemiColon StatementBlock optSemiColon
7598   {
7599     $$=new AltGuard($1, $2, $4);
7600     $$->set_location(infile, @$);
7601   }
7602 | AltGuardChar ApplyOp optSemiColon StatementBlock optSemiColon
7603   {
7604     $$= new AltGuard($1, $2.value, $2.ap_list->steal_tis(), $4);
7605     $$->set_location(infile, @$);
7606     delete $2.ap_list;
7607   }
7608 | AltGuardChar GuardOp ';'
7609   {
7610     $$=new AltGuard($1, $2, new StatementBlock());
7611     $$->set_location(infile, @$);
7612   }
7613 | AltGuardChar GuardOp optSemiColon StatementBlock optSemiColon
7614   {
7615     $$=new AltGuard($1, $2, $4);
7616     $$->set_location(infile, @$);
7617   }
7618 ;
7619
7620 ElseStatement: // 557
7621   '[' ElseKeyword ']' StatementBlock optSemiColon
7622   {
7623     $$=new AltGuard($4);
7624     $$->set_location(infile, @$);
7625   }
7626 ;
7627
7628 AltGuardChar: // 558
7629   '[' ']' { $$=0; }
7630 | '[' BooleanExpression ']' { $$ = $2; }
7631 ;
7632
7633 GuardOp: // 559
7634   TimeoutStatement { $$=$1; }
7635 | ReceiveStatement { $$=$1; }
7636 | TriggerStatement { $$=$1; }
7637 | GetCallStatement { $$=$1; }
7638 | CatchStatement { $$=$1; }
7639 | CheckStatement { $$=$1; }
7640 | GetReplyStatement { $$=$1; }
7641 | DoneStatement { $$=$1; }
7642 | KilledStatement { $$ = $1; }
7643 ;
7644
7645 InterleavedConstruct: // 560
7646   InterleavedKeyword '{' InterleavedGuardList optError '}'
7647   {
7648     $$ = new Statement(Statement::S_INTERLEAVE, $3);
7649     $$->set_location(infile, @$);
7650   }
7651 | InterleavedKeyword '{' error '}'
7652   {
7653     $$ = new Statement(Statement::S_INTERLEAVE, new AltGuards());
7654     $$->set_location(infile, @$);
7655   }
7656 ;
7657
7658 InterleavedGuardList: // 562
7659   optError InterleavedGuardElement
7660   {
7661     $$ = new AltGuards();
7662     $$->add_ag($2);
7663   }
7664 | InterleavedGuardList optError InterleavedGuardElement
7665   { $$ = $1; $$->add_ag($3); }
7666 ;
7667
7668 InterleavedGuardElement: // 563
7669   '[' optError ']' GuardOp ';'
7670   {
7671     $$ = new AltGuard(0, $4, new StatementBlock());
7672     $$->set_location(infile, @$);
7673   }
7674 | '[' optError ']' GuardOp optSemiColon StatementBlock optSemiColon
7675   {
7676     $$ = new AltGuard(0, $4, $6);
7677     $$->set_location(infile, @$);
7678   }
7679 ;
7680
7681 /* The following were folded into the above rule:
7682
7683 InterleavedGuardElement: // 563
7684   InterleavedGuard InterleavedAction
7685 ;
7686
7687 InterleavedGuard: // 564
7688   '[' ']' GuardOp
7689 ;
7690
7691 InterleavedAction: // 565
7692   StatementBlock
7693 ;
7694 */
7695
7696 LabelStatement: // 566
7697   LabelKeyword IDentifier
7698   {
7699     $$=new Statement(Statement::S_LABEL, $2);
7700     $$->set_location(infile, @$);
7701   }
7702 ;
7703
7704 GotoStatement: // 569
7705   GotoKeyword IDentifier
7706   {
7707     $$=new Statement(Statement::S_GOTO, $2);
7708     $$->set_location(infile, @$);
7709   }
7710 | GotoKeyword AltKeyword
7711   {
7712     Location loc(infile, @$);
7713     loc.warning("Obsolete statement `goto alt' was substituted with `repeat'");
7714     $$=new Statement(Statement::S_REPEAT);
7715     $$->set_location(infile, @$);
7716   }
7717 ;
7718
7719 RepeatStatement: // 571
7720   RepeatKeyword
7721   {
7722     $$=new Statement(Statement::S_REPEAT);
7723     $$->set_location(infile, @$);
7724   }
7725 ;
7726
7727 ActivateOp: // 572
7728   ActivateKeyword '(' AltstepInstance optError ')'
7729   {
7730     $$.ref_pard = $3;
7731     $$.derefered_value = 0;
7732     $$.ap_list = 0;
7733   }
7734 | ActivateKeyword '(' DereferOp '(' optFunctionActualParList ')' optError ')'
7735   {
7736     $5->set_location(infile, @4, @6);
7737     $$.ref_pard = 0;
7738     $$.derefered_value = $3;
7739     $$.ap_list = $5->steal_tis(); /* XXX perhaps propagate the datatype instead ? */
7740     delete $5;
7741   }
7742 | ActivateKeyword '(' error ')'
7743   {
7744     $$.ref_pard = 0;
7745     $$.derefered_value = 0;
7746     $$.ap_list = 0;
7747   }
7748 ;
7749
7750 ReferOp:
7751   RefersKeyword '(' FunctionRef ')'
7752   {
7753     Ttcn::Reference* t_ref = new Ttcn::Reference($3.modid, $3.id);
7754     t_ref->set_location(infile, @3);
7755     $$ = new Value(Value::V_REFER, t_ref);
7756     $$->set_location(infile, @$);
7757   }
7758 ;
7759
7760 DeactivateStatement: // 574
7761   DeactivateKeyword
7762   {
7763     $$=new Statement(Statement::S_DEACTIVATE, (Value*)0);
7764     $$->set_location(infile, @$);
7765   }
7766 | DeactivateKeyword '(' Expression optError ')'
7767   {
7768     $$=new Statement(Statement::S_DEACTIVATE, $3);
7769     $$->set_location(infile, @$);
7770   }
7771 | DeactivateKeyword '(' error ')'
7772   {
7773     Value *v = new Value(Value::V_ERROR);
7774     v->set_location(infile, @3);
7775     $$ = new Statement(Statement::S_DEACTIVATE, v);
7776     $$->set_location(infile, @$);
7777   }
7778 ;
7779
7780 BreakStatement: // 576
7781   BreakKeyword
7782   {
7783     $$=new Statement(Statement::S_BREAK);
7784     $$->set_location(infile, @$);
7785   }
7786 ;
7787
7788 ContinueStatement: // 577
7789   ContinueKeyword
7790   {
7791     $$=new Statement(Statement::S_CONTINUE);
7792     $$->set_location(infile, @$);
7793   }
7794 ;
7795
7796 /* A.1.6.8 Basic statements */
7797
7798 BasicStatements: // 578
7799   Assignment
7800   {
7801     $$=new Statement(Statement::S_ASSIGNMENT, $1);
7802     $$->set_location(infile, @$);
7803   }
7804 | LogStatement { $$ = $1; }
7805 | String2TtcnStatement { $$ = $1; }
7806 | StatementBlock
7807   {
7808     $$ = new Statement(Statement::S_BLOCK, $1);
7809     $$->set_location(infile, @$);
7810   }
7811 | TitanSpecificTryKeyword StatementBlock
7812   {
7813     $$ = new Statement(Statement::S_BLOCK, $2);
7814     $2->set_exception_handling(StatementBlock::EH_TRY);
7815     $$->set_location(infile, @$);
7816   }
7817 | TitanSpecificCatchKeyword '(' IDentifier ')' StatementBlock
7818   {
7819     $$ = new Statement(Statement::S_BLOCK, $5);
7820     $5->set_exception_handling(StatementBlock::EH_CATCH);
7821     /* add a newly constructed first statement which will contain the error message,
7822        same as: 'var charstring IDentifier;' */
7823     Type* str_type = new Type(Type::T_CSTR);
7824     str_type->set_location(infile, @3);
7825     Def_Var* str_def = new Def_Var($3, str_type, 0);
7826     str_def->set_location(infile, @3);
7827     Statement* str_stmt = new Statement(Statement::S_DEF, str_def);
7828     str_stmt->set_location(infile, @3);
7829     $5->add_stmt(str_stmt, true);
7830     $$->set_location(infile, @$);
7831   }
7832 | LoopConstruct { $$ = $1; }
7833 | ConditionalConstruct { $$ = $1; }
7834 | SelectCaseConstruct { $$ = $1; }
7835 ;
7836
7837 Expression: // 579
7838   '(' optError Expression optError ')' { $$ = $3; }
7839 | '(' error ')'
7840   {
7841     $$ = new Value(Value::V_ERROR);
7842     $$->set_location(infile, @$);
7843   }
7844 | '+' Expression %prec UnarySign
7845   {
7846     $$ = new Value(Value::OPTYPE_UNARYPLUS, $2);
7847     $$->set_location(infile, @$);
7848   }
7849 | '-' Expression %prec UnarySign
7850   {
7851     $$ = new Value(Value::OPTYPE_UNARYMINUS, $2);
7852     $$->set_location(infile, @$);
7853   }
7854 | Expression '*' Expression
7855   {
7856     $$ = new Value(Value::OPTYPE_MULTIPLY, $1, $3);
7857     $$->set_location(infile, @$);
7858   }
7859 | Expression '/' Expression
7860   {
7861     $$ = new Value(Value::OPTYPE_DIVIDE, $1, $3);
7862     $$->set_location(infile, @$);
7863   }
7864 | Expression ModKeyword Expression
7865   {
7866     $$ = new Value(Value::OPTYPE_MOD, $1, $3);
7867     $$->set_location(infile, @$);
7868   }
7869 | Expression RemKeyword Expression
7870   {
7871     $$ = new Value(Value::OPTYPE_REM, $1, $3);
7872     $$->set_location(infile, @$);
7873   }
7874 | Expression '+' Expression
7875   {
7876     $$ = new Value(Value::OPTYPE_ADD, $1, $3);
7877     $$->set_location(infile, @$);
7878   }
7879 | Expression '-' Expression
7880   {
7881     $$ = new Value(Value::OPTYPE_SUBTRACT, $1, $3);
7882     $$->set_location(infile, @$);
7883   }
7884 | Expression '&' Expression
7885   {
7886     $$ = new Value(Value::OPTYPE_CONCAT, $1, $3);
7887     $$->set_location(infile, @$);
7888   }
7889 | Not4bKeyword Expression
7890   {
7891     $$ = new Value(Value::OPTYPE_NOT4B, $2);
7892     $$->set_location(infile, @$);
7893   }
7894 | Expression And4bKeyword Expression
7895   {
7896     $$ = new Value(Value::OPTYPE_AND4B, $1, $3);
7897     $$->set_location(infile, @$);
7898   }
7899 | Expression Xor4bKeyword Expression
7900   {
7901     $$ = new Value(Value::OPTYPE_XOR4B, $1, $3);
7902     $$->set_location(infile, @$);
7903   }
7904 | Expression Or4bKeyword Expression
7905   {
7906     $$ = new Value(Value::OPTYPE_OR4B, $1, $3);
7907     $$->set_location(infile, @$);
7908   }
7909 | Expression SL Expression
7910   {
7911     $$ = new Value(Value::OPTYPE_SHL, $1, $3);
7912     $$->set_location(infile, @$);
7913   }
7914 | Expression SR Expression
7915   {
7916     $$ = new Value(Value::OPTYPE_SHR, $1, $3);
7917     $$->set_location(infile, @$);
7918   }
7919 | Expression RL Expression
7920   {
7921     $$ = new Value(Value::OPTYPE_ROTL, $1, $3);
7922     $$->set_location(infile, @$);
7923   }
7924 | Expression _RR Expression
7925   {
7926     $$ = new Value(Value::OPTYPE_ROTR, $1, $3);
7927     $$->set_location(infile, @$);
7928   }
7929 | Expression '<' Expression
7930   {
7931     $$ = new Value(Value::OPTYPE_LT, $1, $3);
7932     $$->set_location(infile, @$);
7933   }
7934 | Expression '>' Expression
7935   {
7936     $$ = new Value(Value::OPTYPE_GT, $1, $3);
7937     $$->set_location(infile, @$);
7938   }
7939 | Expression LE Expression
7940   {
7941     $$ = new Value(Value::OPTYPE_LE, $1, $3);
7942     $$->set_location(infile, @$);
7943   }
7944 | Expression GE Expression
7945   {
7946     $$ = new Value(Value::OPTYPE_GE, $1, $3);
7947     $$->set_location(infile, @$);
7948   }
7949 | Expression EQ Expression
7950   {
7951     $$ = new Value(Value::OPTYPE_EQ, $1, $3);
7952     $$->set_location(infile, @$);
7953   }
7954 | Expression NE Expression
7955   {
7956     $$ = new Value(Value::OPTYPE_NE, $1, $3);
7957     $$->set_location(infile, @$);
7958   }
7959 | NotKeyword Expression
7960   {
7961     $$ = new Value(Value::OPTYPE_NOT, $2);
7962     $$->set_location(infile, @$);
7963   }
7964 | Expression AndKeyword Expression
7965   {
7966     $$ = new Value(Value::OPTYPE_AND, $1, $3);
7967     $$->set_location(infile, @$);
7968   }
7969 | Expression XorKeyword Expression
7970   {
7971     $$ = new Value(Value::OPTYPE_XOR, $1, $3);
7972     $$->set_location(infile, @$);
7973   }
7974 | Expression OrKeyword Expression
7975   {
7976     $$ = new Value(Value::OPTYPE_OR, $1, $3);
7977     $$->set_location(infile, @$);
7978   }
7979 | OpCall { $$ = $1; }
7980 | Value { $$ = $1; }
7981 | CompoundExpression { $$ = $1; }
7982 ;
7983
7984 CompoundExpression: // 565
7985   FieldExpressionList { $$ = $1; }
7986 | ArrayExpressionList { $$ = $1; }
7987 | ArrayExpression { $$ = $1; }
7988 ;
7989
7990 FieldExpressionList: // 581
7991   '{' seqFieldExpressionSpec optError '}'
7992   {
7993     $$ = new Value(Value::V_SEQ, $2);
7994     $$->set_location(infile, @$);
7995   }
7996 ;
7997
7998 seqFieldExpressionSpec:
7999   FieldExpressionSpec
8000   {
8001     $$ = new NamedValues();
8002     $$->add_nv($1);
8003   }
8004 | error FieldExpressionSpec
8005   {
8006     $$ = new NamedValues();
8007     $$->add_nv($2);
8008   }
8009 | seqFieldExpressionSpec optError ',' optError FieldExpressionSpec
8010   {
8011     $$ = $1;
8012     $$->add_nv($5);
8013   }
8014 | seqFieldExpressionSpec optError ',' error { $$ = $1; }
8015 ;
8016
8017 FieldExpressionSpec: // 582
8018   FieldReference AssignmentChar NotUsedOrExpression
8019   {
8020     $$ = new NamedValue($1, $3);
8021     $$->set_location(infile, @$);
8022   }
8023 ;
8024
8025 ArrayExpressionList:
8026   '{' seqArrayExpressionSpec optError '}'
8027   {
8028     $$ = new Value(Value::V_SEQOF, $2);
8029     $$->set_location(infile, @$);
8030   }
8031 ;
8032
8033 seqArrayExpressionSpec:
8034   optError ArrayExpressionSpec
8035   {
8036     // The only place for indexed-list notation.
8037     $$ = new Values(true);
8038     $$->add_iv($2);
8039   }
8040 | seqArrayExpressionSpec optError ',' optError ArrayExpressionSpec
8041   {
8042     $$ = $1;
8043     $$->add_iv($5);
8044   }
8045 | seqArrayExpressionSpec optError ',' error { $$ = $1; }
8046 ;
8047
8048 ArrayExpressionSpec:
8049   ArrayOrBitRef AssignmentChar Expression
8050   {
8051     $$ = new IndexedValue($1, $3);
8052     $$->set_location(infile, @$);
8053   }
8054 ;
8055
8056 ArrayExpression: // 583
8057   '{' '}'
8058   {
8059     $$ = new Value(Value::V_SEQOF, new Values);
8060     $$->set_location(infile, @$);
8061   }
8062 | '{' ArrayElementExpressionList optError '}'
8063   {
8064     $$ = new Value(Value::V_SEQOF, $2);
8065     $$->set_location(infile, @$);
8066   }
8067 | '{' error '}'
8068   {
8069     $$ = new Value(Value::V_ERROR);
8070     $$->set_location(infile, @$);
8071   }
8072 ;
8073
8074 ArrayElementExpressionList: // 584
8075   NotUsedOrExpression
8076   {
8077     $$ = new Values;
8078     $$->add_v($1);
8079   }
8080 | error NotUsedOrExpression
8081   {
8082     $$ = new Values;
8083     $$->add_v($2);
8084   }
8085 | ArrayElementExpressionList optError ',' optError NotUsedOrExpression
8086   {
8087     $$ = $1;
8088     $$->add_v($5);
8089   }
8090 | ArrayElementExpressionList optError ',' error { $$ = $1; }
8091 ;
8092
8093 NotUsedOrExpression: // 585
8094   Expression { $$ = $1; }
8095 | NotUsedSymbol
8096   {
8097     $$ = new Value(Value::V_NOTUSED);
8098     $$->set_location(infile, @$);
8099   }
8100 ;
8101
8102 BooleanExpression: // 588
8103   Expression { $$ = $1; }
8104 | error
8105   {
8106     $$ = new Value(Value::V_ERROR);
8107     $$->set_location(infile, @$);
8108   }
8109 ;
8110
8111 Assignment: // 594
8112   VariableRef AssignmentChar TemplateBody
8113   {
8114     $$ = new Ttcn::Assignment($1, $3);
8115     $$->set_location(infile, @$);
8116   }
8117 ;
8118
8119 /* This can not be a single CompoundExpression (as opposed to Expression) */
8120 SingleExpression: // 595
8121   '(' SingleExpression ')' { $$ = $2; }
8122 | '(' error SingleExpression ')' { $$ = $3; }
8123 | '(' error ')'
8124   {
8125     $$ = new Value(Value::V_ERROR);
8126     $$->set_location(infile, @$);
8127   }
8128 | '+' Expression %prec UnarySign
8129   {
8130     $$ = new Value(Value::OPTYPE_UNARYPLUS, $2);
8131     $$->set_location(infile, @$);
8132   }
8133 | '-' Expression %prec UnarySign
8134   {
8135     $$ = new Value(Value::OPTYPE_UNARYMINUS, $2);
8136     $$->set_location(infile, @$);
8137   }
8138 | SingleExpression '*' Expression
8139   {
8140     $$ = new Value(Value::OPTYPE_MULTIPLY, $1, $3);
8141     $$->set_location(infile, @$);
8142   }
8143 | SingleExpression '/' Expression
8144   {
8145     $$ = new Value(Value::OPTYPE_DIVIDE, $1, $3);
8146     $$->set_location(infile, @$);
8147   }
8148 | SingleExpression ModKeyword Expression
8149   {
8150     $$ = new Value(Value::OPTYPE_MOD, $1, $3);
8151     $$->set_location(infile, @$);
8152   }
8153 | SingleExpression RemKeyword Expression
8154   {
8155     $$ = new Value(Value::OPTYPE_REM, $1, $3);
8156     $$->set_location(infile, @$);
8157   }
8158 | SingleExpression '+' Expression
8159   {
8160     $$ = new Value(Value::OPTYPE_ADD, $1, $3);
8161     $$->set_location(infile, @$);
8162   }
8163 | SingleExpression '-' Expression
8164   {
8165     $$ = new Value(Value::OPTYPE_SUBTRACT, $1, $3);
8166     $$->set_location(infile, @$);
8167   }
8168 | SingleExpression '&' Expression
8169   {
8170     $$ = new Value(Value::OPTYPE_CONCAT, $1, $3);
8171     $$->set_location(infile, @$);
8172   }
8173 | Not4bKeyword Expression
8174   {
8175     $$ = new Value(Value::OPTYPE_NOT4B, $2);
8176     $$->set_location(infile, @$);
8177   }
8178 | SingleExpression And4bKeyword Expression
8179   {
8180     $$ = new Value(Value::OPTYPE_AND4B, $1, $3);
8181     $$->set_location(infile, @$);
8182   }
8183 | SingleExpression Xor4bKeyword Expression
8184   {
8185     $$ = new Value(Value::OPTYPE_XOR4B, $1, $3);
8186     $$->set_location(infile, @$);
8187   }
8188 | SingleExpression Or4bKeyword Expression
8189   {
8190     $$ = new Value(Value::OPTYPE_OR4B, $1, $3);
8191     $$->set_location(infile, @$);
8192   }
8193 | SingleExpression SL Expression
8194   {
8195     $$ = new Value(Value::OPTYPE_SHL, $1, $3);
8196     $$->set_location(infile, @$);
8197   }
8198 | SingleExpression SR Expression
8199   {
8200     $$ = new Value(Value::OPTYPE_SHR, $1, $3);
8201     $$->set_location(infile, @$);
8202   }
8203 | SingleExpression RL Expression
8204   {
8205     $$ = new Value(Value::OPTYPE_ROTL, $1, $3);
8206     $$->set_location(infile, @$);
8207   }
8208 | SingleExpression _RR Expression
8209   {
8210     $$ = new Value(Value::OPTYPE_ROTR, $1, $3);
8211     $$->set_location(infile, @$);
8212   }
8213 | SingleExpression '<' Expression
8214   {
8215     $$ = new Value(Value::OPTYPE_LT, $1, $3);
8216     $$->set_location(infile, @$);
8217   }
8218 | SingleExpression '>' Expression
8219   {
8220     $$ = new Value(Value::OPTYPE_GT, $1, $3);
8221     $$->set_location(infile, @$);
8222   }
8223 | SingleExpression LE Expression
8224   {
8225     $$ = new Value(Value::OPTYPE_LE, $1, $3);
8226     $$->set_location(infile, @$);
8227   }
8228 | SingleExpression GE Expression
8229   {
8230     $$ = new Value(Value::OPTYPE_GE, $1, $3);
8231     $$->set_location(infile, @$);
8232   }
8233 | SingleExpression EQ Expression
8234   {
8235     $$ = new Value(Value::OPTYPE_EQ, $1, $3);
8236     $$->set_location(infile, @$);
8237   }
8238 | SingleExpression NE Expression
8239   {
8240     $$ = new Value(Value::OPTYPE_NE, $1, $3);
8241     $$->set_location(infile, @$);
8242   }
8243 | NotKeyword Expression
8244   {
8245     $$ = new Value(Value::OPTYPE_NOT, $2);
8246     $$->set_location(infile, @$);
8247   }
8248 | SingleExpression AndKeyword Expression
8249   {
8250     $$ = new Value(Value::OPTYPE_AND, $1, $3);
8251     $$->set_location(infile, @$);
8252   }
8253 | SingleExpression XorKeyword Expression
8254   {
8255     $$ = new Value(Value::OPTYPE_XOR, $1, $3);
8256     $$->set_location(infile, @$);
8257   }
8258 | SingleExpression OrKeyword Expression
8259   {
8260     $$ = new Value(Value::OPTYPE_OR, $1, $3);
8261     $$->set_location(infile, @$);
8262   }
8263 | OpCall { $$ = $1; }
8264 | Value { $$ = $1; }
8265 ;
8266
8267 optExtendedFieldReference:
8268 // perhaps this should be called seqExtendedFieldReference,
8269 // but the convention appears to be that seq... can not be empty
8270   /* empty */
8271   {
8272     $$.nElements = 0;
8273     $$.elements = 0;
8274   }
8275 | optExtendedFieldReference FieldOrArrayReference
8276   {
8277     $$.nElements = $1.nElements + 1;
8278     $$.elements = (FieldOrArrayRef**)
8279       Realloc($1.elements, ($$.nElements) * sizeof(*$$.elements));
8280     $$.elements[$1.nElements] = $2;
8281   }
8282 ;
8283
8284 FieldOrArrayReference:
8285   '.' FieldIdentifier
8286   {
8287     $$ = new FieldOrArrayRef($2);
8288     $$->set_location(infile, @$);
8289   }
8290   | ArrayOrBitRefOrDash { $$ = $1; }
8291 ;
8292
8293 FieldIdentifier:
8294   PredefOrIdentifier { $$ = $1; }
8295 | IDentifier /* maybe PredefOrIdentifier here too */ TypeActualParList
8296   {
8297     Location loc(infile, @$);
8298     loc.error("Reference to a parameterized field of type `anytype' is "
8299       "not currently supported");
8300     $$ = $1;
8301   }
8302 ;
8303
8304 OpCall: // 611
8305   ConfigurationOps { $$ = $1; }
8306 | VerdictOps { $$ = $1; }
8307 | TimerOps { $$ = $1; }
8308 | TestcaseInstance
8309   {
8310     if ($1.ref_pard) $$ = new Value(Value::OPTYPE_EXECUTE, $1.ref_pard,
8311       $1.value);
8312     else if($1.derefered_value)
8313       $$ = new Value(Value::OPTYPE_EXECUTE_REFD, $1.derefered_value, $1.ap_list,
8314       $1.value);
8315     else $$ = new Value(Value::V_ERROR);
8316     $$->set_location(infile, @$);
8317   }
8318 | FunctionInstance
8319   {
8320     $$ = new Value(Value::V_REFD, $1);
8321     $$->set_location(infile, @$);
8322   }
8323 | ApplyOp
8324   {
8325     $$ = new Value(Value::V_INVOKE, $1.value, $1.ap_list);
8326     $$->set_location(infile, @$);
8327   }
8328 | TemplateOps { $$ = $1; }
8329 | PredefinedOps { $$ = $1; }
8330 | ReferOp { $$ = $1; }
8331 | ActivateOp
8332   {
8333     if ($1.ref_pard) $$ = new Value(Value::OPTYPE_ACTIVATE, $1.ref_pard);
8334     else if($1.derefered_value) $$ = new Value(Value::OPTYPE_ACTIVATE_REFD,
8335       $1.derefered_value, new ParsedActualParameters($1.ap_list));
8336     else $$ = new Value(Value::V_ERROR);
8337     $$->set_location(infile, @$);
8338   }
8339 ;
8340
8341 PredefinedOps:
8342   PredefinedOpKeyword1 '(' optError Expression optError ')'
8343   {
8344     $$ = new Value($1, $4);
8345     $$->set_location(infile, @$);
8346   }
8347 |  PredefinedOpKeyword1 '(' error ')'
8348   {
8349     Value *v1 = new Value(Value::V_ERROR);
8350     v1->set_location(infile, @3);
8351     $$ = new Value($1, v1);
8352     $$->set_location(infile, @$);
8353   }
8354 | PredefinedOpKeyword2 '(' optError Expression optError ',' optError
8355   Expression optError ')'
8356   {
8357     $$ = new Value($1, $4, $8);
8358     $$->set_location(infile, @$);
8359   }
8360 | PredefinedOpKeyword2 '(' error ')'
8361   {
8362     Value *v1 = new Value(Value::V_ERROR);
8363     v1->set_location(infile, @3);
8364     Value *v2 = new Value(Value::V_ERROR);
8365     v2->set_location(infile, @3);
8366     $$ = new Value($1, v1, v2);
8367     $$->set_location(infile, @$);
8368   }
8369 | PredefinedOpKeyword3 '(' optError Expression optError ',' optError
8370   Expression optError ')'
8371   {
8372     $$ = new Value($1, $4, $8);
8373     $$->set_location(infile, @$);
8374   }
8375 | PredefinedOpKeyword3 '(' optError Expression optError ')'
8376   {
8377     $$ = new Value($1, $4, (Common::Value*)NULL);
8378     $$->set_location(infile, @$);
8379   }
8380 | PredefinedOpKeyword3 '(' error ')'
8381   {
8382     Value *v1 = new Value(Value::V_ERROR);
8383     v1->set_location(infile, @3);
8384     Value *v2 = new Value(Value::V_ERROR);
8385     v2->set_location(infile, @3);
8386     $$ = new Value($1, v1, v2);
8387     $$->set_location(infile, @$);
8388   }
8389 | decompKeyword '(' optError Expression optError ',' optError
8390   Expression optError ',' optError Expression optError ')'
8391   {
8392     $$ = new Value(Value::OPTYPE_DECOMP, $4, $8, $12);
8393     $$->set_location(infile, @$);
8394   }
8395 | decompKeyword '(' error ')'
8396   {
8397     Value *v1 = new Value(Value::V_ERROR);
8398     v1->set_location(infile, @3);
8399     Value *v2 = new Value(Value::V_ERROR);
8400     v2->set_location(infile, @3);
8401     Value *v3 = new Value(Value::V_ERROR);
8402     v3->set_location(infile, @3);
8403     $$ = new Value(Value::OPTYPE_DECOMP, v1, v2, v3);
8404     $$->set_location(infile, @$);
8405   }
8406 | regexpKeyword '(' optError TemplateInstance optError ',' optError
8407   TemplateInstance optError ',' optError Expression optError ')'
8408   {
8409     $$ = new Value(Value::OPTYPE_REGEXP, $4, $8, $12);
8410     $$->set_location(infile, @$);
8411   }
8412 | regexpKeyword '(' error ')'
8413   {
8414     Template *t1 = new Template(Template::TEMPLATE_ERROR);
8415     t1->set_location(infile, @3);
8416     TemplateInstance *ti1 = new TemplateInstance(0, 0, t1);
8417     ti1->set_location(infile, @3);
8418     Template *t2 = new Template(Template::TEMPLATE_ERROR);
8419     t2->set_location(infile, @3);
8420     TemplateInstance *ti2 = new TemplateInstance(0, 0, t2);
8421     ti2->set_location(infile, @3);
8422     Value *v3 = new Value(Value::V_ERROR);
8423     v3->set_location(infile, @3);
8424     $$ = new Value(Value::OPTYPE_REGEXP, ti1, ti2, v3);
8425     $$->set_location(infile, @$);
8426   }
8427 | encvalueKeyword '(' optError TemplateInstance optError ')'
8428   {
8429     $$ = new Value(Value::OPTYPE_ENCODE, $4);
8430     $$->set_location(infile, @$);
8431   }
8432 | encvalueKeyword '(' error ')'
8433   {
8434     Template *t1 = new Template(Template::TEMPLATE_ERROR);
8435     t1->set_location(infile, @3);
8436     TemplateInstance *ti1 = new TemplateInstance(0, 0, t1);
8437     ti1->set_location(infile, @3);
8438     $$ = new Value(Value::OPTYPE_ENCODE, ti1);
8439     $$->set_location(infile, @$);
8440   }
8441 | substrKeyword '(' optError TemplateInstance optError ',' optError
8442   Expression optError ',' optError Expression optError ')'
8443   {
8444     $$ = new Value(Value::OPTYPE_SUBSTR, $4, $8, $12);
8445     $$->set_location(infile, @$);
8446   }
8447 | substrKeyword '(' error ')'
8448   {
8449     Template *t1 = new Template(Template::TEMPLATE_ERROR);
8450     t1->set_location(infile, @3);
8451     TemplateInstance *ti1 = new TemplateInstance(0, 0, t1);
8452     ti1->set_location(infile, @3);
8453     Value *v2 = new Value(Value::V_ERROR);
8454     v2->set_location(infile, @3);
8455     Value *v3 = new Value(Value::V_ERROR);
8456     v3->set_location(infile, @3);
8457     $$ = new Value(Value::OPTYPE_SUBSTR, ti1, v2, v3);
8458     $$->set_location(infile, @$);
8459   }
8460 | replaceKeyword '(' optError TemplateInstance optError ',' optError
8461   Expression optError ',' optError Expression optError ',' optError
8462   TemplateInstance optError ')'
8463   {
8464     $$ = new Value(Value::OPTYPE_REPLACE, $4, $8, $12, $16);
8465     $$->set_location(infile, @$);
8466   }
8467 | replaceKeyword '(' error ')'
8468   {
8469     Template *t1 = new Template(Template::TEMPLATE_ERROR);
8470     t1->set_location(infile, @3);
8471     TemplateInstance *ti1 = new TemplateInstance(0, 0, t1);
8472     ti1->set_location(infile, @3);
8473     Value *v2 = new Value(Value::V_ERROR);
8474     v2->set_location(infile, @3);
8475     Value *v3 = new Value(Value::V_ERROR);
8476     v3->set_location(infile, @3);
8477     Template *t4 = new Template(Template::TEMPLATE_ERROR);
8478     t4->set_location(infile, @3);
8479     TemplateInstance *ti4 = new TemplateInstance(0, 0, t4);
8480     ti4->set_location(infile, @3);
8481     $$ = new Value(Value::OPTYPE_REPLACE, ti1, v2, v3, ti4);
8482     $$->set_location(infile, @$);
8483   }
8484 | decvalueKeyword '(' optError DecValueArg optError ',' optError DecValueArg optError ')'
8485   {
8486     $$ = new Value(Value::OPTYPE_DECODE, $4, $8);
8487     $$->set_location(infile, @$);
8488   }
8489 | decvalueKeyword '(' error ')'
8490   {
8491     /*Value *v1 = new Value(Value::V_ERROR);
8492     v1->set_location(infile, @3);
8493     TemplateInstance *t2 = new TemplateInstance(Type::T_ERROR);*/
8494     $$ = new Value(Value::V_ERROR);
8495     $$->set_location(infile, @$);
8496   }
8497 | isvalueKeyword '(' optError TemplateInstance optError ')'
8498   {
8499     $$ = new Value(Value::OPTYPE_ISVALUE, $4);
8500     $$->set_location(infile, @$);
8501   }
8502 | isvalueKeyword '(' error ')'
8503   {
8504     $$ = new Value(Value::V_ERROR);
8505     $$->set_location(infile, @$);
8506   }
8507 | isboundKeyword '(' optError TemplateInstance optError ')'
8508   {
8509     $$ = new Value(Value::OPTYPE_ISBOUND, $4);
8510     $$->set_location(infile, @$);
8511   }
8512 | isboundKeyword '(' error ')'
8513   {
8514     $$ = new Value(Value::V_ERROR);
8515     $$->set_location(infile, @$);
8516   }
8517 | ischosenKeyword '(' optError IschosenArg optError ')'
8518   {
8519     $$ = new Value(Value::OPTYPE_ISCHOSEN, $4.ref, $4.id);
8520     $$->set_location(infile, @$);
8521   }
8522 | ischosenKeyword '(' error ')'
8523   {
8524     $$ = new Value(Value::V_ERROR);
8525     $$->set_location(infile, @$);
8526   }
8527 | ispresentKeyword '(' optError TemplateInstance optError ')'
8528   {
8529     $$ = new Value(Value::OPTYPE_ISPRESENT, $4);
8530     $$->set_location(infile, @$);
8531   }
8532 | ispresentKeyword '(' error ')'
8533   {
8534     $$ = new Value(Value::V_ERROR);
8535     $$->set_location(infile, @$);
8536   }
8537 | lengthofKeyword '(' optError TemplateInstance optError ')'
8538   {
8539     $$ = new Value(Value::OPTYPE_LENGTHOF, $4);
8540     $$->set_location(infile, @$);
8541   }
8542 | lengthofKeyword '(' error ')'
8543   {
8544     $$ = new Value(Value::V_ERROR);
8545     $$->set_location(infile, @$);
8546   }
8547 | rndKeyword '(' ')'
8548   {
8549     $$ = new Value(Value::OPTYPE_RND);
8550     $$->set_location(infile, @$);
8551   }
8552 | rndKeyword '(' optError Expression optError ')'
8553   {
8554     $$ = new Value(Value::OPTYPE_RNDWITHVAL, $4);
8555     $$->set_location(infile, @$);
8556   }
8557 | rndKeyword '(' error ')'
8558   {
8559     Value *v = new Value(Value::V_ERROR);
8560     v->set_location(infile, @3);
8561     $$ = new Value(Value::OPTYPE_RNDWITHVAL, v);
8562     $$->set_location(infile, @$);
8563   }
8564 | sizeofKeyword '(' optError TemplateInstance optError ')'
8565   {
8566     $$ = new Value(Value::OPTYPE_SIZEOF, $4);
8567     $$->set_location(infile, @$);
8568   }
8569 | sizeofKeyword '(' error ')'
8570   {
8571     $$ = new Value(Value::V_ERROR);
8572     $$->set_location(infile, @$);
8573   }
8574 | log2strKeyword '(' ')'
8575   {
8576     $$ = new Value(Value::OPTYPE_LOG2STR, new LogArguments());
8577     $$->set_location(infile, @$);
8578   }
8579 | log2strKeyword '(' LogItemList optError ')'
8580   {
8581     $$ = new Value(Value::OPTYPE_LOG2STR, $3);
8582     $$->set_location(infile, @$);
8583   }
8584 | log2strKeyword '(' error ')'
8585   {
8586     $$ = new Value(Value::OPTYPE_LOG2STR, new LogArguments());
8587     $$->set_location(infile, @$);
8588   }
8589 | testcasenameKeyword '(' ')'
8590   {
8591     $$ = new Value(Value::OPTYPE_TESTCASENAME);
8592     $$->set_location(infile, @$);
8593   }
8594 | ttcn2stringKeyword '(' optError TemplateInstance optError ')'
8595   {
8596     $$ = new Value(Value::OPTYPE_TTCN2STRING, $4);
8597     $$->set_location(infile, @$);
8598   }
8599 | ttcn2stringKeyword '(' error ')'
8600   {
8601     $$ = new Value(Value::V_ERROR);
8602     $$->set_location(infile, @$);
8603   }
8604 ;
8605
8606 DecValueArg:
8607   Reference
8608   {
8609     if ($1.is_ref) $$ = $1.ref;
8610     else {
8611       $$ = new Ttcn::Reference($1.id);
8612       $$->set_location(infile, @$);
8613     }
8614   }
8615 | FunctionInstance { $$ = $1; }
8616 ;
8617
8618 PredefOrIdentifier:
8619   IDentifier { $$ = $1; }
8620 | PredefinedType /* shall not be "anytype" */
8621   {
8622     // Construct an identifier "on the fly" ($1 here is just a typetype_t)
8623     const char* builtin_typename = Type::get_typename_builtin($1);
8624     if (0 == builtin_typename) FATAL_ERROR("Unexpected type %d", $1);
8625     const string& at_field = anytype_field(string(builtin_typename));
8626
8627     $$ = new Identifier(Identifier::ID_TTCN, at_field);
8628   }
8629
8630 IschosenArg: /* see also Reference... */
8631   IDentifier '.' PredefOrIdentifier
8632   {
8633     $$.ref = new Ttcn::Reference($1);
8634     $$.ref->set_location(infile, @1);
8635     $$.id = $3;
8636   }
8637 | IDentifier '.' PredefOrIdentifier optExtendedFieldReference '.' PredefOrIdentifier
8638   {
8639     $$.ref = new Ttcn::Reference($1);
8640     FieldOrArrayRef *fieldref = new FieldOrArrayRef($3);
8641     fieldref->set_location(infile, @3);
8642     $$.ref->add(fieldref);
8643     for(size_t i=0; i<$4.nElements; i++) $$.ref->add($4.elements[i]);
8644     Free($4.elements);
8645     $$.ref->set_location(infile, @1, @4);
8646     $$.id = $6;
8647   }
8648 | IDentifier ArrayOrBitRef optExtendedFieldReference '.' PredefOrIdentifier
8649   {
8650     $$.ref = new Ttcn::Reference($1);
8651     $$.ref->add($2);
8652     for(size_t i=0; i<$3.nElements; i++) $$.ref->add($3.elements[i]);
8653     Free($3.elements);
8654     $$.ref->set_location(infile, @1, @3);
8655     $$.id = $5;
8656   }
8657 | IDentifier '.' ObjectIdentifierValue '.' IDentifier optExtendedFieldReference
8658   '.' PredefOrIdentifier
8659   {
8660     $$.ref = new Ttcn::Reference($1, $5);
8661     delete $3;
8662     for(size_t i=0; i<$6.nElements; i++) $$.ref->add($6.elements[i]);
8663     Free($6.elements);
8664     $$.ref->set_location(infile, @1, @6);
8665     $$.id = $8;
8666   }
8667 ;
8668
8669 PredefinedOpKeyword1:
8670   bit2hexKeyword { $$ = Value::OPTYPE_BIT2HEX; }
8671 | bit2intKeyword { $$ = Value::OPTYPE_BIT2INT; }
8672 | bit2octKeyword { $$ = Value::OPTYPE_BIT2OCT; }
8673 | bit2strKeyword { $$ = Value::OPTYPE_BIT2STR; }
8674 | char2intKeyword { $$ = Value::OPTYPE_CHAR2INT; }
8675 | char2octKeyword { $$ = Value::OPTYPE_CHAR2OCT; }
8676 | float2intKeyword { $$ = Value::OPTYPE_FLOAT2INT; }
8677 | float2strKeyword { $$ = Value::OPTYPE_FLOAT2STR; }
8678 | hex2bitKeyword { $$ = Value::OPTYPE_HEX2BIT; }
8679 | hex2intKeyword { $$ = Value::OPTYPE_HEX2INT; }
8680 | hex2octKeyword { $$ = Value::OPTYPE_HEX2OCT; }
8681 | hex2strKeyword { $$ = Value::OPTYPE_HEX2STR; }
8682 | int2charKeyword { $$ = Value::OPTYPE_INT2CHAR; }
8683 | int2floatKeyword { $$ = Value::OPTYPE_INT2FLOAT; }
8684 | int2strKeyword { $$ = Value::OPTYPE_INT2STR; }
8685 | int2unicharKeyword { $$ = Value::OPTYPE_INT2UNICHAR; }
8686 | oct2bitKeyword { $$ = Value::OPTYPE_OCT2BIT; }
8687 | oct2charKeyword { $$ = Value::OPTYPE_OCT2CHAR; }
8688 | oct2hexKeyword { $$ = Value::OPTYPE_OCT2HEX; }
8689 | oct2intKeyword { $$ = Value::OPTYPE_OCT2INT; }
8690 | oct2strKeyword { $$ = Value::OPTYPE_OCT2STR; }
8691 | str2bitKeyword { $$ = Value::OPTYPE_STR2BIT; }
8692 | str2floatKeyword { $$ = Value::OPTYPE_STR2FLOAT; }
8693 | str2hexKeyword { $$ = Value::OPTYPE_STR2HEX; }
8694 | str2intKeyword { $$ = Value::OPTYPE_STR2INT; }
8695 | str2octKeyword { $$ = Value::OPTYPE_STR2OCT; }
8696 | unichar2intKeyword { $$ = Value::OPTYPE_UNICHAR2INT; }
8697 | unichar2charKeyword { $$ = Value::OPTYPE_UNICHAR2CHAR; }
8698 | enum2intKeyword { $$ = Value::OPTYPE_ENUM2INT; }
8699 | remove_bomKeyWord { $$ = Value::OPTYPE_REMOVE_BOM; }
8700 | get_stringencodingKeyWord { $$ = Value::OPTYPE_GET_STRINGENCODING; }
8701 | decode_base64KeyWord { $$ = Value::OPTYPE_DECODE_BASE64; }
8702 ;
8703
8704 PredefinedOpKeyword2:
8705   int2bitKeyword { $$ = Value::OPTYPE_INT2BIT; }
8706 | int2hexKeyword { $$ = Value::OPTYPE_INT2HEX; }
8707 | int2octKeyword { $$ = Value::OPTYPE_INT2OCT; }
8708 ;
8709
8710 PredefinedOpKeyword3:
8711   unichar2octKeyword { $$ = Value::OPTYPE_UNICHAR2OCT; }
8712 | oct2unicharKeyword { $$ = Value::OPTYPE_OCT2UNICHAR; }
8713 | encode_base64KeyWord { $$ = Value::OPTYPE_ENCODE_BASE64; }
8714 ;
8715
8716 String2TtcnStatement:
8717   string2ttcnKeyword '(' optError Expression optError ',' optError Reference optError ')'
8718   {
8719     Ttcn::Reference* out_ref;
8720     if ($8.is_ref) out_ref = $8.ref;
8721     else {
8722       out_ref = new Ttcn::Reference($8.id);
8723       out_ref->set_location(infile, @8);
8724     }
8725     $$ = new Statement(Statement::S_STRING2TTCN, $4, out_ref);
8726     $$->set_location(infile, @$);
8727   }
8728 ;
8729
8730 LogStatement: // 619
8731   LogKeyword '(' ')'
8732   {
8733     $$=new Statement(Statement::S_LOG, (LogArguments*)0);
8734     $$->set_location(infile, @$);
8735   }
8736 | LogKeyword '(' LogItemList optError ')'
8737   {
8738     $$=new Statement(Statement::S_LOG, $3);
8739     $$->set_location(infile, @$);
8740   }
8741 | LogKeyword '(' error ')'
8742   {
8743     $$=new Statement(Statement::S_LOG, new LogArguments());
8744     $$->set_location(infile, @$);
8745   }
8746 ;
8747
8748 LogItemList:
8749   optError LogItem
8750   {
8751     $$ = new LogArguments();
8752     $$->add_logarg($2);
8753   }
8754 | LogItemList optError ',' optError LogItem
8755   {
8756     $$ = $1;
8757     $$->add_logarg($5);
8758   }
8759 | LogItemList optError ',' error { $$ = $1; }
8760 ;
8761
8762 LogItem: // 621
8763   TemplateInstance
8764   {
8765     $$ = new LogArgument($1);
8766     $$->set_location(infile, @$);
8767   }
8768 ;
8769
8770 LoopConstruct: // 622
8771   ForStatement { $$ = $1; }
8772 | WhileStatement { $$ = $1; }
8773 | DoWhileStatement { $$ = $1; }
8774 ;
8775
8776 ForStatement: // 623
8777   ForKeyword '(' Initial ';' Final ';' Step optError ')'
8778   StatementBlock
8779   {
8780     $$ = new Statement(Statement::S_FOR, $3.defs, $3.ass, $5, $7, $10);
8781     $$->set_location(infile, @$);
8782   }
8783 ;
8784
8785 Initial: // 625
8786   VarInstance
8787   {
8788     $$.defs = new Definitions;
8789     for (size_t i = 0; i < $1.nElements; i++) $$.defs->add_ass($1.elements[i]);
8790     Free($1.elements);
8791     $$.ass = 0;
8792   }
8793 | Assignment
8794   {
8795     $$.defs = 0;
8796     $$.ass = $1;
8797   }
8798 | error
8799   {
8800     $$.defs = new Definitions;
8801     $$.ass = 0;
8802   }
8803 ;
8804
8805 Final: // 626
8806   BooleanExpression { $$ = $1; }
8807 ;
8808
8809 Step: // 627
8810   Assignment { $$ = $1; }
8811 /** \todo for-ban nem lehet null a step
8812 | error { $$=NULL; }
8813 */
8814 ;
8815
8816 WhileStatement: // 628
8817   WhileKeyword '(' BooleanExpression ')' StatementBlock
8818 {
8819   $$=new Statement(Statement::S_WHILE, $3, $5);
8820   $$->set_location(infile, @$);
8821 }
8822 ;
8823
8824 DoWhileStatement: // 630
8825   DoKeyword StatementBlock
8826   WhileKeyword '(' BooleanExpression ')'
8827   {
8828     $$=new Statement(Statement::S_DOWHILE, $5, $2);
8829     $$->set_location(infile, @$);
8830   }
8831 ;
8832
8833 ConditionalConstruct: // 632
8834   IfKeyword '(' BooleanExpression ')'
8835   StatementBlock
8836   seqElseIfClause optElseClause
8837   {
8838     IfClause *ic=new IfClause($3, $5);
8839     ic->set_location(infile, @1, @5);
8840     $6->add_front_ic(ic);
8841     $$=new Statement(Statement::S_IF, $6, $7,
8842                      $7 ? new Location(infile, @7) : 0);
8843     $$->set_location(infile, @$);
8844   }
8845 ;
8846
8847 seqElseIfClause:
8848   /* empty */ { $$=new IfClauses(); }
8849 | seqElseIfClause ElseIfClause
8850   {
8851     $$=$1;
8852     $$->add_ic($2);
8853   }
8854 ;
8855
8856 ElseIfClause: // 634
8857   ElseKeyword IfKeyword '(' BooleanExpression ')' StatementBlock
8858   {
8859     $$=new IfClause($4, $6);
8860     $$->set_location(infile, @$);
8861   }
8862 ;
8863
8864 optElseClause: // [636]
8865   /* empty */ { $$=0; }
8866 | ElseKeyword StatementBlock { $$=$2; }
8867 ;
8868
8869 SelectCaseConstruct: // 637
8870   SelectKeyword '(' Expression optError ')' SelectCaseBody
8871   {
8872     $$=new Statement(Statement::S_SELECT, $3, $6);
8873     $$->set_location(infile, @$);
8874   }
8875 | SelectKeyword '(' error ')' SelectCaseBody
8876   {
8877     Value *v = new Value(Value::V_ERROR);
8878     v->set_location(infile, @3);
8879     $$=new Statement(Statement::S_SELECT, v, $5);
8880     $$->set_location(infile, @$);
8881   }
8882 ;
8883
8884 SelectCaseBody: // 639
8885   '{' seqSelectCase optError '}' {$$=$2;}
8886 | '{' error '}' {$$=new SelectCases;}
8887 ;
8888
8889 seqSelectCase:
8890   optError SelectCase
8891   {
8892     $$=new SelectCases;
8893     $$->add_sc($2);
8894   }
8895 | seqSelectCase optError SelectCase
8896   {
8897     $$=$1;
8898     $$->add_sc($3);
8899   }
8900 ;
8901
8902 SelectCase: // 640
8903   CaseKeyword '(' seqTemplateInstance optError ')' StatementBlock optSemiColon
8904   {
8905     $3->set_location(infile, @2, @5);
8906     $$=new SelectCase($3, $6);
8907     $$->set_location(infile, @$);
8908   }
8909 | CaseKeyword '(' error ')' StatementBlock optSemiColon
8910   {
8911     TemplateInstances *tis = new TemplateInstances;
8912     tis->set_location(infile, @2, @4);
8913     $$ = new SelectCase(tis, $5);
8914     $$->set_location(infile, @$);
8915   }
8916 | CaseKeyword ElseKeyword StatementBlock optSemiColon
8917   {
8918     $$=new SelectCase(0, $3);
8919     $$->set_location(infile, @$);
8920   }
8921 ;
8922
8923 seqTemplateInstance:
8924   optError TemplateInstance
8925   {
8926     $$ = new TemplateInstances;
8927     $$->add_ti($2);
8928   }
8929 | seqTemplateInstance optError ',' optError TemplateInstance
8930   {
8931     $$ = $1;
8932     $$->add_ti($5);
8933   }
8934 | seqTemplateInstance optError ',' error { $$ = $1; }
8935 ;
8936
8937 /* A.1.6.9 Miscellaneous productions */
8938
8939 optSemiColon: // [645]
8940   /* empty */
8941 | ';'
8942 ;
8943
8944 /* A.1 ASN.1 support, from ES 201 873-7 V3.1.1 (2005-06) */
8945
8946 optDefinitiveIdentifier:
8947   /* empty */
8948 | DefinitiveIdentifier
8949 ;
8950
8951 DefinitiveIdentifier:
8952   '.' ObjectIdentifierKeyword '{' DefinitiveObjIdComponentList optError '}'
8953 | '.' ObjectIdentifierKeyword '{' error '}'
8954 ;
8955
8956 DefinitiveObjIdComponentList:
8957   optError DefinitiveObjIdComponent
8958 | DefinitiveObjIdComponentList optError DefinitiveObjIdComponent
8959 ;
8960
8961 DefinitiveObjIdComponent:
8962   NameForm
8963 | DefinitiveNumberForm
8964 | DefinitiveNameAndNumberForm
8965 ;
8966
8967 DefinitiveNumberForm:
8968   Number { delete $1; }
8969 ;
8970
8971 DefinitiveNameAndNumberForm:
8972   IDentifier '(' Number optError ')' { delete $1; delete $3; }
8973 | IDentifier '(' error ')' { delete $1; }
8974 ;
8975
8976 ObjectIdentifierValue:
8977   ObjectIdentifierKeyword '{' ObjIdComponentList optError '}'
8978   {
8979     $$ = $3;
8980     $$->set_location(infile, @$);
8981   }
8982 | ObjectIdentifierKeyword '{' error '}'
8983   {
8984     $$ = new Value(Value::V_ERROR);
8985     $$->set_location(infile, @$);
8986   }
8987 ;
8988
8989 ObjIdComponentList:
8990   optError ObjIdComponent
8991   {
8992     $$ = new Value(Value::V_OID);
8993     $$->add_oid_comp($2);
8994   }
8995 | ObjIdComponentList optError ObjIdComponent
8996   {
8997     $$ = $1;
8998     $$->add_oid_comp($3);
8999   }
9000 ;
9001
9002 ObjIdComponent:
9003 /* NameForm -- covered by NumberForm (as ReferencedValue) */
9004   NumberForm { $$ = $1; }
9005 | NameAndNumberForm { $$ = $1; }
9006 ;
9007
9008 NumberForm:
9009   Number
9010   {
9011     Value *v = new Value(Value::V_INT, $1);
9012     v->set_location(infile, @1);
9013     $$ = new OID_comp(0, v);
9014     $$->set_location(infile, @$);
9015   }
9016 | Reference
9017   {
9018     if ($1.is_ref) {
9019       /* it can be only a referenced value */
9020       Value *v = new Value(Value::V_REFD, $1.ref);
9021       v->set_location(infile, @1);
9022       $$ = new OID_comp(v);
9023     } else {
9024       /* it can be either a name form or a referenced value */
9025       $$ = new OID_comp($1.id, 0);
9026     }
9027     $$->set_location(infile, @$);
9028   }
9029 ;
9030
9031 NameAndNumberForm:
9032   IDentifier '(' Number optError ')'
9033   {
9034     Value *v = new Value(Value::V_INT, $3);
9035     v->set_location(infile, @3);
9036     $$ = new OID_comp($1, v);
9037     $$->set_location(infile, @$);
9038   }
9039 | IDentifier '(' ReferencedValue optError ')'
9040   {
9041     $$ = new OID_comp($1, $3);
9042     $$->set_location(infile, @$);
9043   }
9044 | IDentifier '(' error ')'
9045   {
9046     Value *v = new Value(Value::V_ERROR);
9047     v->set_location(infile, @3);
9048     $$ = new OID_comp($1, v);
9049     $$->set_location(infile, @$);
9050   }
9051 ;
9052
9053 NameForm:
9054   IDentifier { delete $1; }
9055 ;
9056
9057 /* Rules for error recovery */
9058
9059 optError:
9060   /* empty */
9061 | error
9062 ;
9063
9064 optErrorBlock:
9065   optError
9066 | optErrorBlock ErrorBlock optError
9067 ;
9068
9069 ErrorBlock:
9070   '{' error '}'
9071 | '{' optError ErrorBlock optError '}'
9072 ;
9073
9074 %%
9075
9076 static void ttcn3_error(const char *str)
9077 {
9078   Location loc(infile, ttcn3_lloc);
9079   if (*ttcn3_text) {
9080     // the most recently parsed token is known
9081     loc.error("at or before token `%s': %s", ttcn3_text, str);
9082   } else {
9083     // the most recently parsed token is unknown
9084     loc.error("%s", str);
9085   }
9086 }
9087
9088 int ttcn3_parse_file(const char* filename, boolean generate_code)
9089 {
9090   anytype_access = false;
9091   ttcn3_in = fopen(filename, "r");
9092   if (ttcn3_in == NULL) {
9093     ERROR("Cannot open input file `%s': %s", filename, strerror(errno));
9094     return -1;
9095   }
9096   infile = filename;
9097   init_ttcn3_lex();
9098
9099   is_erroneous_parsed = false;
9100   NOTIFY("Parsing TTCN-3 module `%s'...", filename);
9101
9102   int retval = ttcn3_parse();
9103
9104   free_ttcn3_lex(); // does fclose(ttcn3_in);
9105
9106   if (act_ttcn3_module) {
9107     act_ttcn3_module->set_location(filename);
9108     set_md5_checksum(act_ttcn3_module);
9109     if (generate_code) act_ttcn3_module->set_gen_code();
9110     modules->add_mod(act_ttcn3_module);
9111     act_ttcn3_module = 0;
9112   }
9113
9114   act_group = 0;
9115
9116   return retval;
9117 }
9118
9119 Ttcn::ErroneousAttributeSpec* ttcn3_parse_erroneous_attr_spec_string(
9120   const char* p_str, const Common::Location& str_loc)
9121 {
9122   is_erroneous_parsed = true;
9123   act_ttcn3_erroneous_attr_spec = NULL;
9124   string titan_err_str("$#&&&(#TITANERRONEOUS$#&&^#% ");
9125   int hack_str_len = (int)titan_err_str.size();
9126   string *parsed_string = parse_charstring_value(p_str, str_loc);
9127   titan_err_str += *parsed_string;
9128   delete parsed_string;
9129   init_erroneous_lex(str_loc.get_filename(), str_loc.get_first_line(), str_loc.get_first_column()-hack_str_len+1);
9130   yy_buffer_state *flex_buffer = ttcn3__scan_string(titan_err_str.c_str());
9131   if (flex_buffer == NULL) {
9132     ERROR("Flex buffer creation failed.");
9133     return NULL;
9134   }
9135   yyparse();
9136   ttcn3_lex_destroy();
9137   free_dot_flag_stuff();
9138
9139   return act_ttcn3_erroneous_attr_spec;
9140 }
9141
9142 #ifndef NDEBUG
9143 static void yyprint(FILE *file, int type, const YYSTYPE& value)
9144 {
9145   switch (type) {
9146     case IDentifier:
9147       fprintf(file, "``%s''", value.id->get_name().c_str());
9148       break;
9149     case Number:
9150       fprintf(file, "%s", value.int_val->t_str().c_str());
9151       break;
9152     case FloatValue:
9153       fprintf(file, "%f", value.float_val);
9154       break;
9155     case Bstring:
9156     case Hstring:
9157     case Ostring:
9158     case BitStringMatch:
9159     case HexStringMatch:
9160     case OctetStringMatch:
9161       fprintf(file, "``%s''", value.string_val->c_str());
9162       break;
9163     case Cstring:
9164       fprintf(file, "``%s''", value.str);
9165       break;
9166     default:
9167       break;
9168   }
9169 }
9170 #endif