compiler.y

/******************************************************************************
 * Copyright (c) 2000-2016 Ericsson Telecom AB
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Baji, Laszlo
 *   Balasko, Jeno
 *   Baranyi, Botond
 *   Beres, Szabolcs
 *   Cserveni, Akos
 *   Delic, Adam
 *   Dimitrov, Peter
 *   Feher, Csaba
 *   Forstner, Matyas
 *   Gecse, Roland
 *   Kovacs, Ferenc
 *   Kremer, Peter
 *   Pandi, Krisztian
 *   Raduly, Csaba
 *   Szabados, Kristof
 *   Szabo, Bence Janos
 *   Szabo, Janos Zoltan – initial implementation
 *   Szalai, Gabor
 *   Tatarka, Gabor
 *   Zalanyi, Balazs Andor
 *
 ******************************************************************************/
/* Syntax check parser and compiler for TTCN-3 */

/* BNF compliance: v3.2.1 with extensions */

%{

/* C declarations */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#include "../../common/dbgnew.hh"
#include "../../common/memory.h"

#include "../datatypes.h"
#include "Attributes.hh"
#include "../main.hh"
#include "compiler.h"

#include "../Identifier.hh"
#include "Templatestuff.hh"
#include "AST_ttcn3.hh"
#include "../Type.hh"
#include "../CompType.hh"
#include "../CompField.hh"
#include "../EnumItem.hh"
#include "../SigParam.hh"

#include "../subtype.hh"
#include "../Value.hh"
#include "../Valuestuff.hh"
#include "../ustring.hh"
#include "Ttcnstuff.hh"
#include "TtcnTemplate.hh"
#include "Templatestuff.hh"
#include "ArrayDimensions.hh"
#include "PatternString.hh"
#include "Statement.hh"

using namespace Ttcn;
using namespace Common;

const char *infile = NULL;

static Ttcn::Module *act_ttcn3_module = NULL;
static Ttcn::ErroneousAttributeSpec *act_ttcn3_erroneous_attr_spec = NULL;
bool is_erroneous_parsed = false;
static void ttcn3_error(const char *str);
static Group* act_group = NULL;
extern string anytype_field(const string& type_name);
static bool anytype_access = false;

#ifndef NDEBUG

union YYSTYPE;
static void yyprint(FILE *file, int type, const YYSTYPE& value);
#define YYPRINT(f,t,v) yyprint(f,t,v)

#endif

extern Modules *modules;

extern FILE *ttcn3_in;
extern char *ttcn3_text;
extern int ttcn3_lex();
extern void init_ttcn3_lex();
extern void free_ttcn3_lex();
extern void set_md5_checksum(Ttcn::Module *m);

extern void init_erroneous_lex(const char* p_infile, int p_line, int p_column);
struct yy_buffer_state;
extern int ttcn3_lex_destroy(void);
extern yy_buffer_state *ttcn3__scan_string(const char *yy_str);
extern void free_dot_flag_stuff();

extern string *parse_charstring_value(const char *str, const Location& loc);
extern PatternString* parse_pattern(const char *str, const Location& loc);

static const string anyname("anytype");

/* Various C macros */

#define YYERROR_VERBOSE


%}

/* Bison declarations */

/*********************************************************************
 * The union-type
 *********************************************************************/

%union {
  /* NOTE: the union is written to compiler.tab.hh, which is #included
   * into compiler.l; therefore all types used here must be declared
   * in compiler.l (forward declared or #included) */
  bool bool_val; /* boolean value */
  char *str; /* simple string value */
  unsigned char uchar_val;

  int_val_t *int_val; /* integer value */
  Real float_val; /* float value */
  Identifier *id;
  string *string_val;
  ustring *ustring_val;

  Type::typetype_t typetype;
  PortTypeBody::PortOperationMode_t portoperationmode;
  Value::operationtype_t operationtype;
  Value::macrotype_t macrotype;
  SingleWithAttrib::attribtype_t attribtype;
  ImpMod::imptype_t imptype;

  AltGuard *altguard;
  AltGuards *altguards;
  ArrayDimension *arraydimension;
  AttributeSpec *attributespec;
  CompField *compfield;
  CompFieldMap *compfieldmap;
  Def_Type *deftype;
  Def_Timer *deftimer;
  Definition *definition;
  Definitions *defs;
  EnumItem *enumitem;
  EnumItems *enumitems;
  FieldOrArrayRef *fieldorarrayref;
  FormalPar *formalpar;
  FormalParList *formalparlist;
  Group *group;
  FriendMod *friendMod;
  IfClause *ifclause;
  IfClauses *ifclauses;
  ImpMod *impmod;
  LengthRestriction *lenrestr;
  LogArgument *logarg;
  LogArguments *logargs;
  NamedTemplate *namedtempl;
  NamedTemplates *namedtempls;
  NamedValue *namedvalue;
  NamedValues *namedvalues;
  IndexedTemplate *indexedtempl;
  IndexedTemplates *indexedtempls;
  IndexedValue *indexedvalue;
  MultiWithAttrib *multiwithattrib;
  OID_comp *oidcomp;
  ParamAssignment *parass;
  ParamAssignments *parasss;
  ParamRedirect *parredir;
  ParsedActualParameters *parsedpar;
  PatternString *patstr;
  Qualifier *qualifier;
  Qualifiers *qualifiers;
  SelectCase *selectcase;
  SelectCases *selectcases;
  SignatureExceptions *signexc;
  SignatureParam *signparam;
  SignatureParamList *signparamlist;
  SingleWithAttrib *singlewithattrib;
  Statement *stmt;
  StatementBlock *statementblock;
  SubTypeParse *subtypeparse;
  Template *templ;
  TemplateInstance *templinst;
  TemplateInstances *templinsts;
  Templates *templs;
  Ttcn::Assignment *ass;
  Ttcn::Ref_base *refbase;
  Ttcn::Ref_pard *refpard;
  Ttcn::Reference *reference;
  ValueRange *valuerange;
  Type *type;
  Types *types;
  Value *value;
  Values *values;
  VariableEntries *variableentries;
  VariableEntry *variableentry;
  vector<SubTypeParse> *subtypeparses;
  CompTypeRefList *comprefs;
  ComponentTypeBody *compbody;
  template_restriction_t template_restriction;

  struct {
    bool is_raw;
    ErroneousAttributeSpec::indicator_t indicator;
  } erroneous_indicator;

  struct arraydimension_list_t {
    size_t nElements;
    ArrayDimension **elements;
  } arraydimension_list;

  struct {
    size_t nElements;
    FieldOrArrayRef **elements;
  } fieldorarrayref_list;

  struct {
    size_t nElements;
    Ttcn::Definition **elements;
  } def_list;

  struct {
    size_t nElements;
    Ttcn::FriendMod **elements;
  } friend_list;

  struct {
    size_t nElements;
    Statement **elements;
  } stmt_list;

  struct {
    size_t nElements;
    const char **elements;
  } uid_list;

  struct {
    Value *lower;
    bool lower_exclusive;
    Value *upper;
    bool upper_exclusive;
  } rangedef;

  struct {
    Type *type;
    bool returns_template;
    template_restriction_t template_restriction;
  } returntype;

  struct {
    Type *type;
    bool no_block_kw;
  } returntypeornoblock;

  struct {
    Identifier *id;
    CompFieldMap* cfm;
  } structdefbody;

  struct {
    Type *type;
    Identifier *id;
  } structofdefbody;

  struct {
    Ttcn::Types *in_list, *out_list, *inout_list;
    bool in_all, out_all, inout_all;
  } portdefbody;

  struct {
    Ttcn::Reference *ref;
    Identifier *id;
  } ischosenarg;

  struct {
    bool is_ifpresent;
    LengthRestriction *len_restr;
  } extramatchingattrs;

  struct {
    Identifier *name;
    Type *type;
    FormalParList *fp_list;
  } basetemplate;

  struct {
    Identifier *modid;
    Identifier *id;
  } templateref;

  struct {
    Ttcn::Ref_pard *ref_pard;
    Value *derefered_value;
    ParsedActualParameters *ap_list;
    Value *value;
  } testcaseinst;

  struct {
    Ttcn::Ref_pard *ref_pard;
    Value *derefered_value;
    TemplateInstances *ap_list;
  } activateop;

  struct {
    TemplateInstance *templ_inst;
    Value *val;
  } portsendop;

  struct {
    Value *calltimerval; // if NULL: see nowait
    bool nowait;
  } calltimerval;

  struct {
    TemplateInstance *templ_inst;
    Value *calltimerval; // if NULL: see nowait
    bool nowait;
    Value *val; // not used in callparams
  } portcallop;

  struct {
    TemplateInstance *templ_inst;
    Value *replyval;
    Value *toclause;
  } portreplyop;

  struct {
    Ttcn::Reference *signature;
    TemplateInstance *templ_inst;
    Value *toclause;
  } portraiseop;

  struct {
    Ttcn::Reference *redirectval;
    Ttcn::Reference *redirectsender;
  } portredirect;

  struct {
    ParamRedirect *redirectparam;
    Ttcn::Reference *redirectsender;
  } portredirectwithparam;

  struct {
    Ttcn::Reference *redirectval;
    ParamRedirect *redirectparam;
    Ttcn::Reference *redirectsender;
  } portredirectwithvalueandparam;

  struct {
    TemplateInstance *templ_inst;
    TemplateInstance *valuematch;
  } getreplypar;

  struct {
    TemplateInstance *templ_inst;
    TemplateInstance *fromclause;
    Ttcn::Reference *redirectval;
    Ttcn::Reference *redirectsender;
  } portreceiveop;

  struct {
    TemplateInstance *templ_inst;
    TemplateInstance *fromclause;
    ParamRedirect *redirectparam;
    Ttcn::Reference *redirectsender;
  } portgetcallop;

  struct {
    TemplateInstance *templ_inst;
    TemplateInstance *valuematch;
    TemplateInstance *fromclause;
    Ttcn::Reference *redirectval;
    ParamRedirect *redirectparam;
    Ttcn::Reference *redirectsender;
  } portgetreplyop;

  struct {
    Ttcn::Reference *signature;
    TemplateInstance *templ_inst;
    bool timeout;
  } catchoppar;

  struct {
    Ttcn::Reference *signature;
    TemplateInstance *templ_inst;
    bool timeout;
    TemplateInstance *fromclause;
    Ttcn::Reference *redirectval;
    Ttcn::Reference *redirectsender;
  } portcatchop;

  struct {
    Statement::statementtype_t statementtype;
    Ttcn::Reference *signature;
    TemplateInstance *templ_inst;
    TemplateInstance *valuematch;
    bool timeout;
    TemplateInstance *fromclause;
    Ttcn::Reference *redirectval;
    ParamRedirect *redirectparam;
    Ttcn::Reference *redirectsender;
  } portcheckop;

  struct {
    Value *compref;
    Ttcn::Reference *portref;
  } portref;

  struct {
    Value *compref1;
    Ttcn::Reference *portref1;
    Value *compref2;
    Ttcn::Reference *portref2;
  } connspec;

  struct {
    TemplateInstance *donematch;
    Ttcn::Reference *redirect;
  } donepar;

  struct {
    bool is_ref;
    union {
      Ttcn::Reference *ref;
      Identifier *id;
    };
  } reforid;

  struct {
    Definitions *defs;
    Ttcn::Assignment *ass;
  } initial;

  struct {
    Ttcn::Reference *runsonref;
    Ttcn::Reference *systemref;
  } configspec;

  struct {
    Value *name;
    Value *loc;
  } createpar;

  struct {
    Value *value;
    ParsedActualParameters *ap_list;
  } applyop;


  struct extconstidentifier_t {
    Identifier *id;
    YYLTYPE yyloc;
  } extconstidentifier;

  struct {
    size_t nElements;
    extconstidentifier_t *elements;
  } identifier_list;

  struct singlevarinst_t {
    Identifier *id;
    arraydimension_list_t arrays;
    Value *initial_value;
    YYLTYPE yyloc;
  } singlevarinst;

  struct singlevarinst_list_t {
    size_t nElements;
    struct singlevarinst_t *elements;
  } singlevarinst_list;

  struct singletempvarinst_t {
    Identifier *id;
    arraydimension_list_t arrays;
    Template *initial_value;
    YYLTYPE yyloc;
  } singletempvarinst;

  struct singletempvarinst_list_t {
    size_t nElements;
    singletempvarinst_t *elements;
  } singletempvarinst_list;

  struct singlemodulepar_t {
    Identifier *id;
    Value *defval;
    YYLTYPE yyloc;
  } singlemodulepar;

  struct singletemplatemodulepar_t {
    Identifier *id;
    Template *deftempl;
    YYLTYPE yyloc;
  } singletemplatemodulepar;

  struct singlemodulepar_list_t {
    size_t nElements;
    singlemodulepar_t *elements;
  } singlemodulepar_list;

  struct singletemplatemodulepar_list_t {
    size_t nElements;
    singletemplatemodulepar_t *elements;
  } singletemplatemodulepar_list;

  struct portelement_t {
    Identifier *id;
    ArrayDimensions *dims;
    YYLTYPE yyloc;
  } portelement;

  struct portelement_list_t {
    size_t nElements;
    portelement_t *elements;
  } portelement_list;

  struct runs_on_compref_or_self_t {
    bool self;
    Ttcn::Reference *reference;
  } runs_on_compref_or_self;

  struct {
    visibility_t visibility;
  } visbilitytype;
}

/* Tokens of TTCN-3 */

/*********************************************************************
 * Tokens with semantic value
 *********************************************************************/

/* Terminals with semantic value  */

%token <int_val> Number
%token <float_val> FloatValue
%token <id> IDentifier "Identifier"

%token <string_val> Bstring
  Hstring
  Ostring
  BitStringMatch
  HexStringMatch
  OctetStringMatch
%token <str> Cstring
%token NullValue "ASN.1_NULL_value"
%token <macrotype> MacroValue

/*********************************************************************
 * Tokens without semantic value
 *********************************************************************/

/* Terminals without semantic value - keywords, operators, etc. */

%token TOK_errval "erroneous_value"

/* A number of terminals (including ApplyKeyword, CallOpKeyword, etc)
 * are listed as unused by Bison. They do not appear in any rule,
 * because the lexer does some magic to combine them with the preceding dot
 * and returns a (DotApplyKeyword, DotCallOpKeyword, etc) instead.
 * This magic requires the presence of the unused keywords.
 * (It can return an ApplyKeyword if not preceded by a dot) */
%token TitanErroneousHackKeyword
%token ActionKeyword
%token ActivateKeyword
%token AddressKeyword
%token AliveKeyword
%token AllKeyword
%token AltKeyword
%token AltstepKeyword
%token AndKeyword
%token And4bKeyword
%token AnyKeyword
%token AnyTypeKeyword
%token ApplyKeyword
%token BitStringKeyword
%token BooleanKeyword
%token BreakKeyword
%token CallOpKeyword
%token CaseKeyword
%token CatchOpKeyword
%token CharKeyword
%token CharStringKeyword
%token CheckOpKeyword
%token ClearOpKeyword
%token ComplementKeyword
%token ComponentKeyword
%token ConnectKeyword
%token ConstKeyword
%token ContinueKeyword
%token ControlKeyword
%token CreateKeyword
%token DeactivateKeyword
%token DefaultKeyword
%token DerefersKeyword
%token DisconnectKeyword
%token DisplayKeyword
%token DoKeyword
%token DoneKeyword
%token ElseKeyword
%token EncodeKeyword
%token EnumKeyword
%token ErrorKeyword
%token ExceptKeyword
%token ExceptionKeyword
%token ExecuteKeyword
%token ExtendsKeyword
%token ExtensionKeyword
%token ExtKeyword
%token FailKeyword
%token FalseKeyword
%token FloatKeyword
%token ForKeyword
%token FriendKeyword
%token FromKeyword
%token FunctionKeyword
%token GetCallOpKeyword
%token GetReplyOpKeyword
%token GetVerdictKeyword
%token GotoKeyword
%token GroupKeyword
%token HaltKeyword
%token HexStringKeyword
%token IfKeyword
%token IfPresentKeyword
%token ImportKeyword
%token InconcKeyword
%token InfinityKeyword
%token InOutParKeyword
%token InParKeyword
%token IntegerKeyword
%token InterleavedKeyword
%token KillKeyword
%token KilledKeyword
%token LabelKeyword
%token LanguageKeyword
%token LengthKeyword
%token LogKeyword
%token MapKeyword
%token MatchKeyword
%token MessageKeyword
%token MixedKeyword
%token ModKeyword
%token ModifiesKeyword
%token ModuleParKeyword
%token MTCKeyword
%token NaNKeyword
%token NoBlockKeyword
%token NoneKeyword
%token NotKeyword
%token Not4bKeyword
%token NowaitKeyword
%token NullKeyword
%token ObjectIdentifierKeyword
%token OctetStringKeyword
%token OfKeyword
%token OmitKeyword
%token OnKeyword
%token OptionalKeyword
%token OrKeyword
%token Or4bKeyword
%token OutParKeyword
%token OverrideKeyword
%token PassKeyword
%token ParamKeyword
%token PatternKeyword
%token PermutationKeyword
%token PresentKeyword
%token PortKeyword
%token PrivateKeyword
%token ProcedureKeyword
%token PublicKeyword
%token RaiseKeyword
%token ReadKeyword
%token ReceiveOpKeyword
%token RecordKeyword
%token RecursiveKeyword
%token RefersKeyword
%token RemKeyword
%token RepeatKeyword
%token ReplyKeyword
%token ReturnKeyword
%token RunningKeyword
%token RunsKeyword
%token SelectKeyword
%token SelfKeyword
%token SenderKeyword
%token SendOpKeyword
%token SetKeyword
%token SetVerdictKeyword
%token SignatureKeyword
%token StartKeyword
%token StopKeyword
%token SubsetKeyword
%token SupersetKeyword
%token SystemKeyword
%token TemplateKeyword
%token TestcaseKeyword
%token TimeoutKeyword
%token TimerKeyword
%token ToKeyword
%token TriggerOpKeyword
%token TrueKeyword
%token TTCN3ModuleKeyword
%token TypeDefKeyword
%token UnionKeyword
%token UniversalKeyword
%token UnmapKeyword
%token ValueKeyword
%token ValueofKeyword
%token VarKeyword
%token VariantKeyword
%token VerdictTypeKeyword
%token WhileKeyword
%token WithKeyword
%token XorKeyword
%token Xor4bKeyword

/* modifier keywords */
%token NocaseKeyword
%token LazyKeyword

/* TITAN specific keywords */
%token TitanSpecificTryKeyword
%token TitanSpecificCatchKeyword
%token TitanSpecificProfilerKeyword

/* Keywords combined with a leading dot */

/* If a '.' (dot) character is followed by one of the keywords below the
 * lexical analyzer shall return one combined token instead of two distinct
 * tokens. This eliminates the ambiguity that causes additional shift/reduce
 * conflicts because the dot can be either the part of a field reference or a
 * built-in operation denoted by a keyword. */

%token DotAliveKeyword
%token DotApplyKeyword
%token DotCallOpKeyword
%token DotCatchOpKeyword
%token DotCheckOpKeyword
%token DotClearOpKeyword
%token DotCreateKeyword
%token DotDoneKeyword
%token DotGetCallOpKeyword
%token DotGetReplyOpKeyword
%token DotHaltKeyword
%token DotKillKeyword
%token DotKilledKeyword
%token DotRaiseKeyword
%token DotReadKeyword
%token DotReceiveOpKeyword
%token DotReplyKeyword
%token DotRunningKeyword
%token DotSendOpKeyword
%token DotStartKeyword
%token DotStopKeyword
%token DotTimeoutKeyword
%token DotTriggerOpKeyword

/* Predefined function identifiers */

%token bit2hexKeyword
%token bit2intKeyword
%token bit2octKeyword
%token bit2strKeyword
%token char2intKeyword
%token char2octKeyword
%token decompKeyword
%token float2intKeyword
%token hex2bitKeyword
%token hex2intKeyword
%token hex2octKeyword
%token hex2strKeyword
%token int2bitKeyword
%token int2charKeyword
%token int2enumKeyword
%token int2floatKeyword
%token int2hexKeyword
%token int2octKeyword
%token int2strKeyword
%token int2unicharKeyword
%token isvalueKeyword
%token isboundKeyword
%token ischosenKeyword
%token ispresentKeyword
%token lengthofKeyword
%token oct2bitKeyword
%token oct2charKeyword
%token oct2hexKeyword
%token oct2intKeyword
%token oct2strKeyword
%token oct2unicharKeyword
%token regexpKeyword
%token replaceKeyword
%token rndKeyword
%token testcasenameKeyword
%token sizeofKeyword
%token str2floatKeyword
%token str2intKeyword
%token str2octKeyword
%token substrKeyword
%token unichar2intKeyword
%token unichar2charKeyword
%token unichar2octKeyword

%token float2strKeyword
%token str2bitKeyword
%token str2hexKeyword

%token log2strKeyword
%token enum2intKeyword

%token encvalueKeyword
%token decvalueKeyword

%token ttcn2stringKeyword
%token string2ttcnKeyword
%token remove_bomKeyWord
%token get_stringencodingKeyWord
%token encode_base64KeyWord
%token decode_base64KeyWord

/* Multi-character operators */

%token AssignmentChar ":="
%token DotDot ".."
%token PortRedirectSymbol "->"
%token EQ "=="
%token NE "!="
%token GE ">="
%token LE "<="
%token SL "<<"
%token SR ">>"
%token RL "<@"
%token _RR "@>" /* Name clash with bn.h:292 */

/*********************************************************************
 * Semantic types of nonterminals
 *********************************************************************/

%type <bool_val> optAliveKeyword optOptionalKeyword optOverrideKeyword
  optErrValueRaw optAllKeyword optLazyEval
%type <str> FreeText optLanguageSpec PatternChunk PatternChunkList
%type <uchar_val> Group Plane Row Cell
%type <id> FieldIdentifier FieldReference GlobalModuleId
  IdentifierOrAddressKeyword StructFieldRef PredefOrIdentifier
%type <string_val> CstringList
%type <ustring_val> Quadruple
%type <uid_list> USI UIDlike

%type <typetype> PredefinedType
%type <portoperationmode> PortOperationMode
%type <operationtype> PredefinedOpKeyword1 PredefinedOpKeyword2 PredefinedOpKeyword3

%type <activateop> ActivateOp
%type <attribtype> AttribKeyword

%type <altguard> CallBodyStatement AltGuard ElseStatement GuardStatement
  InterleavedGuardElement
%type <altguards> AltGuardList CallBodyStatementList InterleavedGuardList
  optPortCallBody
%type <arraydimension> ArrayIndex
%type <attributespec> AttribSpec
%type <compbody> optComponentDefList ComponentElementDefList
%type <compfield> StructFieldDef UnionFieldDef
%type <compfieldmap> StructFieldDefList optStructFieldDefList UnionFieldDefList
%type <definition> AltstepDef ExtFunctionDef FunctionDef TemplateDef TestcaseDef
%type <deftype> TypeDefBody StructuredTypeDef SubTypeDef RecordDef UnionDef
  SetDef RecordOfDef SetOfDef EnumDef PortDef PortDefBody ComponentDef
  TypeDef SignatureDef FunctionTypeDef AltstepTypeDef TestcaseTypeDef
%type <deftimer> SingleTimerInstance
%type <enumitem> Enumeration
%type <enumitems> EnumerationList
%type <fieldorarrayref> ArrayOrBitRef ArrayOrBitRefOrDash FieldOrArrayReference
%type <formalpar> FormalValuePar FormalTemplatePar FormalTimerPar
  TemplateFormalPar FunctionFormalPar TestcaseFormalPar
%type <formalparlist> optTemplateFormalParList TemplateFormalParList
  optFunctionFormalParList FunctionFormalParList optTestcaseFormalParList
  TestcaseFormalParList optAltstepFormalParList
%type <group> GroupDef GroupIdentifier
%type <friend_list> FriendModuleDef
%type <ifclause> ElseIfClause
%type <ifclauses> seqElseIfClause
%type <impmod> ImportFromSpec ModuleId ImportDef
%type <lenrestr> optStringLength LengthMatch StringLength
%type <logarg> LogItem
%type <logargs> LogItemList
%type <multiwithattrib> MultiWithAttrib WithAttribList WithStatement
  optWithStatement optWithStatementAndSemiColon
%type <namedtempl> FieldSpec
%type <namedtempls> seqFieldSpec
%type <namedvalue> FieldExpressionSpec
%type <namedvalues> seqFieldExpressionSpec
%type <indexedtempl> ArraySpec
%type <indexedtempls> seqArraySpec
%type <indexedvalue> ArrayExpressionSpec
%type <oidcomp> NumberForm NameAndNumberForm ObjIdComponent
%type <parass> VariableAssignment
%type <parasss> AssignmentList
%type <parredir> ParamAssignmentList ParamSpec
%type <patstr> CharStringMatch
%type <qualifier> DefOrFieldRef FullGroupIdentifier
%type <qualifiers> DefOrFieldRefList optAttribQualifier
%type <selectcase> SelectCase
%type <selectcases> seqSelectCase SelectCaseBody
%type <signexc> ExceptionTypeList optExceptionSpec
%type <signparam> SignatureFormalPar
%type <signparamlist> SignatureFormalParList optSignatureFormalParList
%type <singlewithattrib> SingleWithAttrib
%type <stmt> AltConstruct BasicStatements BreakStatement BehaviourStatements
  CallBodyOps CallStatement CatchStatement CheckStatement ClearStatement
  CommunicationStatements ConditionalConstruct ConfigurationStatements
  ConnectStatement ContinueStatement ControlStatement DeactivateStatement
  DisconnectStatement DoWhileStatement DoneStatement ForStatement
  FunctionStatement GetCallStatement GetReplyStatement GotoStatement GuardOp
  HaltStatement InterleavedConstruct KillTCStatement KilledStatement
  LabelStatement LogStatement LoopConstruct MapStatement RaiseStatement
  ReceiveStatement RepeatStatement ReplyStatement ReturnStatement SUTStatements
  SendStatement SetLocalVerdict StartStatement StartTCStatement
  StartTimerStatement StopExecutionStatement StopStatement StopTCStatement
  StopTimerStatement TimeoutStatement TimerStatements TriggerStatement
  UnmapStatement VerdictStatements WhileStatement SelectCaseConstruct
  StopTestcaseStatement String2TtcnStatement ProfilerStatement int2enumStatement
%type <statementblock> StatementBlock optElseClause FunctionStatementOrDefList
  ControlStatementOrDefList ModuleControlBody
%type <subtypeparse> ValueOrRange
%type <templ> MatchingSymbol SingleValueOrAttrib SimpleSpec TemplateBody
  ArrayElementSpec ArrayValueOrAttrib FieldSpecList ArraySpecList
  AllElementsFrom TemplateListElem
%type <templinst> AddressRef FromClause FunctionActualPar InLineTemplate
  ReceiveParameter SendParameter TemplateActualPar TemplateInstance
  /* TestcaseActualPar */ ValueMatchSpec optFromClause optParDefaultValue
  optReceiveParameter
%type <parsedpar> FunctionActualParList TestcaseActualParList
  optFunctionActualParList optTestcaseActualParList
  NamedPart UnnamedPart
%type <templinsts>  optTemplateActualParList
  seqTemplateActualPar seqTemplateInstance
%type <templs> ValueOrAttribList seqValueOrAttrib ValueList Complement
  ArrayElementSpecList SubsetMatch SupersetMatch PermutationMatch
%type <ass> Assignment Step
%type <refbase> DerivedRefWithParList TemplateRefWithParList DecValueArg
%type <refpard> FunctionInstance AltstepInstance
%type <reference> PortType optDerivedDef DerivedDef Signature VariableRef
  TimerRef TimerRefOrAny Port PortOrAny PortOrAll ValueSpec
  SenderSpec ComponentType optRunsOnSpec RunsOnSpec optSystemSpec
%type <valuerange> Range
%type <type> NestedEnumDef NestedRecordDef NestedRecordOfDef NestedSetDef
  NestedSetOfDef NestedTypeDef NestedUnionDef PortDefAttribs ReferencedType
  Type TypeOrNestedTypeDef NestedFunctionTypeDef NestedAltstepTypeDef
  NestedTestcaseTypeDef
%type <types> TypeList AllOrTypeList
%type <value> AddressValue AliveOp AllPortsSpec AltGuardChar ArrayBounds
  ArrayExpression ArrayExpressionList BitStringValue BooleanExpression
  BooleanValue CharStringValue ComponentRef ComponentReferenceOrLiteral
  ComponentOrDefaultReference CompoundExpression ConfigurationOps CreateOp
  DereferOp Expression FieldExpressionList Final GetLocalVerdict HexStringValue
  IntegerValue LowerBound MTCOp MatchOp NotUsedOrExpression ObjIdComponentList
  ObjectIdentifierValue OctetStringValue OmitValue OpCall PredefinedOps
  PredefinedValue ReadTimerOp ReferOp ReferencedValue RunningOp RunningTimerOp
  SelfOp SingleExpression SingleLowerBound SystemOp TemplateOps TimerOps
  TimerValue UpperBound Value ValueofOp VerdictOps VerdictValue optReplyValue
  optTestcaseTimerValue optToClause ProfilerRunningOp
%type <values> ArrayElementExpressionList seqArrayExpressionSpec
%type <variableentries> VariableList
%type <variableentry> VariableEntry
%type <subtypeparses> seqValueOrRange AllowedValues optSubTypeSpec

%type <arraydimension_list> optArrayDef
%type <fieldorarrayref_list> optExtendedFieldReference
%type <def_list> AltstepLocalDef AltstepLocalDefList ComponentElementDef
  ConstDef ExtConstDef FunctionLocalDef FunctionLocalInst ModuleDef ModulePar
  ModuleParDef MultiTypedModuleParList PortInstance TimerInstance TimerList
  VarInstance
%type <stmt_list> FunctionStatementOrDef ControlStatementOrDef

%type <rangedef> RangeDef
%type <returntype> optReturnType
%type <returntypeornoblock> optReturnTypeOrNoBlockKeyword
%type <structdefbody> StructDefBody UnionDefBody
%type <structofdefbody> StructOfDefBody
%type <portdefbody> PortDefList seqPortDefList PortDefLists
%type <ischosenarg> IschosenArg
%type <extramatchingattrs> optExtraMatchingAttributes
%type <basetemplate> BaseTemplate
%type <templateref> TemplateRef TestcaseRef FunctionRef
%type <testcaseinst> TestcaseInstance