core/config_process.l

   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 %option noyywrap
   9 %option never-interactive
  10 %option nounput
  11
  12 %{
  13
  14 #include <string.h>
  15 #include <stdlib.h>
  16 #include <assert.h>
  17
  18 #include <deque>
  19 #include <string>
  20
  21 #include "../common/cfg_process_utils.hh"
  22 #include "../common/Path2.hh"
  23
  24 #include "../common/memory.h"
  25 #include "Types.h"
  26 #include "Parameters.h"
  27 #include "Param_Types.hh"
  28 #include "Port.hh"
  29 #include "LoggingBits.hh"
  30 #include "LoggingParam.hh"
  31 #include "Error.hh"
  32 #include "config_process.tab.hh"
  33 #include "../common/config_preproc.h"
  34 #include "../common/path.h"
  35
  36 #include "../common/dbgnew.hh"
  37
  38 #include "Profiler.hh"
  39
  40 extern string_map_t *config_defines;
  41
  42 #define yylval config_process_lval
  43
  44 static int current_line;
  45
  46 static YY_BUFFER_STATE main_buffer      = NULL;
  47 /* This buffer is used for macro expansion */
  48 static YY_BUFFER_STATE expansion_buffer = NULL;
  49
  50 static std::deque<IncludeElem<YY_BUFFER_STATE> >* include_chain = NULL;
  51
  52 static void set_ret_val_cstr(const std::string& cstring) {
  53   param_charstring_t& ch_val = yylval.charstring_val;
  54   ch_val.n_chars = cstring.size();
  55   ch_val.chars_ptr = (char*) Malloc(ch_val.n_chars + 1);
  56   memcpy(ch_val.chars_ptr, cstring.c_str(), cstring.size() + 1);
  57 }
  58
  59 std::string get_cfg_process_current_file() {
  60   if (include_chain && !include_chain->empty()) {
  61     return include_chain->back().get_full_path();
  62   }
  63
  64   return std::string();
  65 }
  66
  67 %}
  68
  69 WHITESPACE [ \t]
  70 WS {WHITESPACE}*
  71 NEWLINE \r|\n|\r\n
  72 LINECOMMENT ("//"|"#")[^\r\n]*{NEWLINE}
  73
  74 NUMBER 0|([1-9][0-9]*)
  75
  76 FLOAT [+-]?({NUMBER}\.[0-9]+)|((({NUMBER}(\.[0-9]+)?)|(\.[0-9]+))[Ee][+-]?{NUMBER})
  77
  78 BIN 0|1
  79 BITSTRING '{BIN}*'B
  80 BINMATCH 0|1|\?|\*
  81 BITSTRINGMATCH '{BINMATCH}*'B
  82 BITSTRING_BAD '[^']*'B
  83
  84 HEX [0-9A-Fa-f]
  85 HEXSTRING '{HEX}*'H
  86 HEXMATCH [0-9A-Fa-f\?\*]
  87 HEXSTRINGMATCH '{HEXMATCH}*'H
  88 HEXSTRING_BAD '[^']*'H
  89
  90 OCT {HEX}{HEX}
  91 OCTETSTRING '{OCT}*'O
  92 OCTMATCH {HEX}{HEX}|\?|\*
  93 OCTETSTRINGMATCH '{OCTMATCH}*'O
  94 OCTETSTRING_BAD '[^']*'O
  95
  96 BINSTRING_BAD '[^']*'
  97
  98 TTCN3IDENTIFIER [A-Za-z][A-Za-z0-9_]*
  99 ASN1LOWERIDENTIFIER [a-z](-?[A-Za-z0-9]+)*
 100
 101 COMPONENT .*\({NUMBER}\)
 102
 103 MACRO_CSTR \${TTCN3IDENTIFIER}|\$"{"{WS}{TTCN3IDENTIFIER}{WS}(","{WS}charstring{WS})?"}"
 104 MACRO_BOOL \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}boolean{WS}"}"
 105 MACRO_FLOAT \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}float{WS}"}"
 106 MACRO_ID \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}identifier{WS}"}"
 107 MACRO_INT \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}integer{WS}"}"
 108 MACRO_BSTR \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}bitstring{WS}"}"
 109 MACRO_HSTR \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}hexstring{WS}"}"
 110 MACRO_OSTR \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}octetstring{WS}"}"
 111 MACRO_BINARY \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}binaryoctet{WS}"}"
 112 MACRO_HOSTNAME \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}hostname{WS}"}"
 113
 114 HOSTNAME [A-Za-z0-9]([A-Za-z0-9_\-]*[A-Za-z0-9])?
 115 DNSNAME {HOSTNAME}(\.{HOSTNAME})*\.?
 116
 117 /* Example: fe80::c002:37ff:fe6c:0%fastethernet0/0 */
 118 IPV6 [0-9A-Fa-f:.]+(%[0-9A-Za-z]+)?
 119
 120 TTCNSTRINGPARSING "$#&&&(#TTCNSTRINGPARSING$#&&^#% "
 121 TTCNSTRINGPARSING_COMPONENT "$#&&&(#TTCNSTRINGPARSING_COMPONENT$#&&^#% "
 122
 123 %x SC_commentblock SC_cstring SC_DEFINE
 124 %s SC_MODULE_PARAMETERS SC_LOGGING SC_TESTPORT_PARAMETERS SC_EXECUTE SC_GROUPS
 125 %s SC_COMPONENTS SC_EXTERNAL_COMMANDS SC_MAIN_CONTROLLER SC_INCLUDE SC_ORDERED_INCLUDE
 126 %s SC_STRING2TTCN_COMPONENT SC_PROFILER
 127
 128 %%
 129
 130         int caller_state = INITIAL;
 131   std::string cstring;
 132   int cstring_start = -1;
 133
 134         /* Eat up comments and whitespaces */
 135
 136 "/*"    {
 137                 caller_state = YY_START;
 138                 BEGIN(SC_commentblock);
 139         }
 140 <SC_commentblock>
 141 {
 142 "*/"            BEGIN(caller_state);
 143 {NEWLINE}       current_line++;
 144 .               /* do nothing */
 145 <<EOF>> {
 146         config_process_error("Unterminated block comment (missing */ at the "
 147             "end of file).");
 148         BEGIN(caller_state);
 149         }
 150 }
 151
 152 {WHITESPACE}
 153 {NEWLINE}       |
 154 {LINECOMMENT}   current_line++;
 155
 156 {TTCNSTRINGPARSING} {
 157   if (Ttcn_String_Parsing::happening()) {
 158     BEGIN(SC_MODULE_PARAMETERS);
 159     return TtcnStringParsingKeyword;
 160   } else {
 161     config_process_error("Invalid character sequence encountered.");
 162   }
 163 }
 164
 165 {TTCNSTRINGPARSING_COMPONENT} {
 166   if (Ttcn_String_Parsing::happening()) {
 167     BEGIN(SC_STRING2TTCN_COMPONENT);
 168     return TtcnStringParsingKeyword;
 169   } else {
 170     config_process_error("Invalid character sequence encountered.");
 171   }
 172 }
 173
 174         /* Section delimiters */
 175
 176 <*>"["{WS}MODULE_PARAMETERS{WS}"]"      {
 177   if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
 178         BEGIN(SC_MODULE_PARAMETERS);
 179         return ModuleParametersKeyword;
 180         }
 181 }
 182
 183 <*>"["{WS}LOGGING{WS}"]"                {
 184   if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
 185         BEGIN(SC_LOGGING);
 186         return LoggingKeyword;
 187         }
 188 }
 189
 190 <*>"["{WS}PROFILER{WS}"]"               {
 191   if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
 192         BEGIN(SC_PROFILER);
 193         return ProfilerKeyword;
 194         }
 195 }
 196
 197 <*>"["{WS}TESTPORT_PARAMETERS{WS}"]"    {
 198   if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
 199         BEGIN(SC_TESTPORT_PARAMETERS);
 200         return TestportParametersKeyword;
 201         }
 202 }
 203
 204 <*>"["{WS}EXECUTE{WS}"]"                {
 205   if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
 206         BEGIN(SC_EXECUTE);
 207         return ExecuteKeyword;
 208         }
 209 }
 210
 211 <*>"["{WS}EXTERNAL_COMMANDS{WS}"]"              {
 212   if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
 213         BEGIN(SC_EXTERNAL_COMMANDS);
 214         return ExternalCommandsKeyword;
 215         }
 216 }
 217
 218 <*>"["{WS}GROUPS{WS}"]"         {
 219   if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
 220         BEGIN(SC_GROUPS);
 221         return GroupsKeyword;
 222         }
 223 }
 224
 225 <*>"["{WS}COMPONENTS{WS}"]"     {
 226   if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
 227         BEGIN(SC_COMPONENTS);
 228         return ComponentsKeyword;
 229         }
 230 }
 231
 232 <*>"["{WS}MAIN_CONTROLLER{WS}"]"                {
 233   if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
 234         BEGIN(SC_MAIN_CONTROLLER);
 235         return MainControllerKeyword;
 236         }
 237 }
 238
 239 <*>"["{WS}INCLUDE{WS}"]"                {
 240   if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
 241         BEGIN(SC_INCLUDE);
 242         return IncludeKeyword;
 243         }
 244 }
 245
 246 <*>"["{WS}ORDERED_INCLUDE{WS}"]"                {
 247   if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
 248         BEGIN(SC_ORDERED_INCLUDE);
 249         }
 250 }
 251
 252 <*>"["{WS}DEFINE{WS}"]"         {
 253   if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
 254         BEGIN(SC_DEFINE);
 255         return DefineKeyword;
 256         }
 257 }
 258
 259         /* Rules for SC_DEFINE must precede everything else */
 260
 261 <SC_DEFINE>{
 262
 263 "/*"    {
 264                 caller_state = SC_DEFINE;
 265                 BEGIN(SC_commentblock);
 266 }
 267
 268 \"  {
 269   caller_state = SC_DEFINE;
 270   BEGIN(SC_cstring);
 271   cstring.clear();
 272   cstring_start = current_line;
 273 }
 274
 275 {LINECOMMENT}|{NEWLINE} current_line++;
 276
 277 \\\"
 278
 279 . /* eat unnecessary chars */
 280
 281 }
 282
 283 <SC_PROFILER>{HEX}+ {
 284   /* numeric statistics filter (check this before checking for NUMBERs) */
 285   yylval.uint_val = 0;
 286   while(0 != *yytext) {
 287     yylval.uint_val *= 16;
 288     if ('0' <= *yytext && '9' >= *yytext) {
 289       yylval.uint_val += *yytext - '0';
 290     }
 291     else if ('a' <= *yytext && 'f' >= *yytext) {
 292       yylval.uint_val += *yytext - 'a' + 10;
 293     }
 294     else {
 295       yylval.uint_val += *yytext - 'A' + 10;
 296     }
 297     ++yytext;
 298   }
 299   return ProfilerStatsFlag;
 300 }
 301
 302         /* Values */
 303
 304 {NUMBER}        {
 305         yylval.int_val = new int_val_t(yytext);
 306         return Number;
 307         }
 308
 309 {FLOAT}         {
 310         yylval.float_val = atof(yytext);
 311         return Float;
 312         }
 313
 314 {BITSTRING}     {
 315         yylval.bitstring_val.n_bits = yyleng - 3;
 316         int n_bytes = (yylval.bitstring_val.n_bits + 7) / 8;
 317         yylval.bitstring_val.bits_ptr = (unsigned char *)Malloc(n_bytes);
 318         memset(yylval.bitstring_val.bits_ptr, 0, n_bytes);
 319         for (int i = 0; i < yylval.bitstring_val.n_bits; i++)
 320                 if (yytext[i+1] == '1')
 321                         yylval.bitstring_val.bits_ptr[i/8] |= 1 << (i % 8);
 322         return Bstring;
 323         }
 324
 325 {BITSTRINGMATCH} {
 326   yylval.str_val = mcopystrn(yytext+1, yyleng-3);
 327   return BstringMatch;
 328 }
 329
 330 {BITSTRING_BAD} {
 331         config_process_error("Invalid bitstring value.");
 332         yylval.bitstring_val.n_bits = 0;
 333         yylval.bitstring_val.bits_ptr = NULL;
 334         return Bstring;
 335 }
 336
 337 {HEXSTRING}     {
 338         yylval.hexstring_val.n_nibbles = yyleng - 3;
 339         int n_bytes = (yylval.hexstring_val.n_nibbles + 1) / 2;
 340         yylval.hexstring_val.nibbles_ptr = (unsigned char *)Malloc(n_bytes);
 341         memset(yylval.hexstring_val.nibbles_ptr, 0, n_bytes);
 342         for (int i = 0; i < yylval.hexstring_val.n_nibbles; i++) {
 343                 unsigned int hex_digit;
 344                 sscanf(yytext+i+1, "%1x", &hex_digit);
 345                 if(i % 2) yylval.hexstring_val.nibbles_ptr[i/2] |=
 346                         (hex_digit << 4);
 347                 else yylval.hexstring_val.nibbles_ptr[i/2] |= hex_digit;
 348         }
 349         return Hstring;
 350         }
 351
 352 {HEXSTRINGMATCH} {
 353   yylval.str_val = mcopystrn(yytext+1, yyleng-3);
 354   return HstringMatch;
 355 }
 356
 357 {HEXSTRING_BAD} {
 358         config_process_error("Invalid hexstring value.");
 359         yylval.hexstring_val.n_nibbles = 0;
 360         yylval.hexstring_val.nibbles_ptr = NULL;
 361         return Hstring;
 362 }
 363
 364 {OCTETSTRING}   {
 365         yylval.octetstring_val.n_octets = (yyleng - 3) / 2;
 366         yylval.octetstring_val.octets_ptr = (unsigned char *)
 367                 Malloc(yylval.octetstring_val.n_octets);
 368
 369         for (int i = 0; i < yylval.octetstring_val.n_octets; i++) {
 370                 unsigned int this_octet;
 371                 sscanf(yytext+2*i+1, "%2x", &this_octet);
 372                 yylval.octetstring_val.octets_ptr[i] = this_octet;
 373         }
 374         return Ostring;
 375         }
 376
 377 {OCTETSTRINGMATCH} {
 378   yylval.str_val = mcopystrn(yytext+1, yyleng-3);
 379   return OstringMatch;
 380 }
 381
 382 {OCTETSTRING_BAD}       {
 383         config_process_error("Invalid octetstring value.");
 384         yylval.octetstring_val.n_octets = 0;
 385         yylval.octetstring_val.octets_ptr = NULL;
 386         return Ostring;
 387 }
 388
 389 {BINSTRING_BAD} config_process_error("Invalid string value.");
 390
 391 '       config_process_error("Unmatched ' character.");
 392
 393 \"      {
 394         caller_state = YY_START;
 395         BEGIN(SC_cstring);
 396   cstring.clear();
 397   cstring_start = current_line;
 398         }
 399
 400 <SC_cstring>
 401 {
 402 \"\"    cstring += '"';
 403 \"      {
 404   /* end of the string */
 405         BEGIN(caller_state);
 406   switch (caller_state) {
 407   case SC_DEFINE:
 408     cstring.clear();
 409     break;
 410   case SC_ORDERED_INCLUDE:
 411     {
 412       std::string error_msg = switch_lexer(include_chain, cstring,
 413           YY_CURRENT_BUFFER, yy_create_buffer, yy_switch_to_buffer,
 414           current_line, YY_BUF_SIZE);
 415       if (error_msg.empty()) {
 416         BEGIN(INITIAL);
 417       } else {
 418         config_process_error(error_msg.c_str());
 419       }
 420     }
 421     break;
 422   default:
 423     set_ret_val_cstr(cstring);
 424     return Cstring;
 425   }
 426
 427   cstring.clear();
 428   cstring_start = -1;
 429         }
 430 \\[\\'"?]       cstring += yytext[1]; /* backslash-quoted \ or " or ' or ? */
 431 \\{NEWLINE}     current_line++;
 432 \\a     cstring += '\a';
 433 \\b     cstring += '\b';
 434 \\f     cstring += '\f';
 435 \\n     cstring += '\n';
 436 \\r     cstring += '\r';
 437 \\t     cstring += '\t';
 438 \\v     cstring += '\v';
 439 \\[0-7]{1,3}    {
 440         unsigned int c;
 441         sscanf(yytext + 1, "%o", &c);
 442         if (c > 255)
 443             config_process_error("Invalid octal character code in string "
 444                 "literal.");
 445         else if (c == 0 && caller_state != SC_MODULE_PARAMETERS)
 446             config_process_error("NUL characters in string literals are "
 447                 "allowed only in section [MODULE_PARAMETERS].");
 448         else cstring += c;
 449         }
 450 \\x{HEX}{1,2}   {
 451         unsigned int c;
 452         sscanf(yytext + 2, "%x", &c);
 453         if (c == 0 && caller_state != SC_MODULE_PARAMETERS)
 454             config_process_error("NUL characters in string literals are "
 455                 "allowed only in section [MODULE_PARAMETERS].");
 456         else cstring += c;
 457         }
 458 \\(x[^\\\"]|.)  {
 459         config_process_error("Invalid escape sequence in string literal.");
 460         }
 461 {NEWLINE}       {
 462   cstring.append(yytext, yyleng);
 463         current_line++;
 464         }
 465 .       cstring += yytext[0];
 466 <<EOF>> {
 467   if (cstring_start >=0) {
 468     config_process_error_f("Unterminated string literal starting at line %d "
 469         "(missing \" at the end of file).", cstring_start);
 470   } else {
 471     config_process_error("Unterminated string literal (missing \" at the "
 472           "end of file).");
 473   }
 474   BEGIN(caller_state);
 475   if (caller_state!=SC_DEFINE) {
 476     set_ret_val_cstr(cstring);
 477           return Cstring;
 478   }
 479
 480   cstring.clear();
 481         }
 482 }
 483
 484         /* Section-wide keywords */
 485
 486 <SC_MODULE_PARAMETERS>
 487 {
 488 NULL            return NULLKeyword;
 489 null            return nullKeyword;
 490 char            return CharKeyword;
 491 objid           return ObjIdKeyword;
 492 omit            return OmitKeyword;
 493 none            {
 494         yylval.verdict_val = NONE;
 495         return VerdictValue;
 496         }
 497 pass            {
 498         yylval.verdict_val = PASS;
 499         return VerdictValue;
 500         }
 501 inconc          {
 502         yylval.verdict_val = INCONC;
 503         return VerdictValue;
 504         }
 505 fail            {
 506         yylval.verdict_val = FAIL;
 507         return VerdictValue;
 508         }
 509 error           {
 510         yylval.verdict_val = ERROR;
 511         return VerdictValue;
 512         }
 513 complement  return ComplementKeyword;
 514 "\.\."      return DotDot;
 515 superset    return SupersetKeyword;
 516 subset      return SubsetKeyword;
 517 pattern     return PatternKeyword;
 518 permutation return PermutationKeyword;
 519 length      return LengthKeyword;
 520 ifpresent   return IfpresentKeyword;
 521 infinity    return InfinityKeyword;
 522 }
 523
 524 <SC_MODULE_PARAMETERS,SC_LOGGING,SC_PROFILER>
 525 {
 526 true            {
 527         yylval.bool_val = TRUE;
 528         return BooleanValue;
 529         }
 530 false           {
 531         yylval.bool_val = FALSE;
 532         return BooleanValue;
 533         }
 534 }
 535
 536   /* We could add SC_LOGGING to make mtc and system special for the logging section too */
 537 <SC_MODULE_PARAMETERS,SC_STRING2TTCN_COMPONENT,SC_TESTPORT_PARAMETERS,SC_LOGGING>
 538 {
 539 mtc             return MTCKeyword;
 540 system          return SystemKeyword;
 541 }
 542
 543 <SC_LOGGING>
 544 {
 545 [Ff]ile[Nn]ame                  |
 546 [Ll]og[Ff]ile                   return LogFile;
 547
 548 [Ee]mergency[Ll]ogging     return EmergencyLogging;
 549
 550 [Ee]mergency[Ll]ogging[Bb]ehaviour     return EmergencyLoggingBehaviour;
 551
 552 [Ee]mergency[Ll]ogging[Mm]ask     return EmergencyLoggingMask;
 553
 554 [Ff]ile[Mm]ask                  return FileMask;
 555
 556 [Cc]onsole[Mm]ask               return ConsoleMask;
 557
 558 [Tt]ime[Ss]tamp[Ff]ormat        return TimestampFormat;
 559 [Cc]onsole[Tt]ime[Ss]tamp[Ff]ormat      return ConsoleTimestampFormat;
 560
 561 [Ll]og[Ss]ource[Ii]nfo          |
 562 [Ss]ource[Ii]nfo[Ff]ormat       return SourceInfoFormat;
 563
 564 [Aa]ppend[Ff]ile                return AppendFile;
 565
 566 [Ll]og[Ee]vent[Tt]ypes          return LogEventTypes;
 567
 568 [Ll]og[Ee]ntity[Nn]ame          return LogEntityName;
 569
 570 [Ll]og[Ff]ile[Ss]ize            return LogFileSize;
 571
 572 [Ll]og[Ff]ile[Nn]umber          return LogFileNumber;
 573
 574 [Dd]isk[Ff]ull[Aa]ction         return DiskFullAction;
 575
 576 [Mm]atching[Hh]ints             return MatchingHints;
 577
 578 [Ll]ogger[Pp]lugins return LoggerPlugins;
 579
 580     /* Lexer's handling of logging keywords:
 581     *
 582     *  For sub-categories and categories with only one member,
 583     *  LoggingBit is returned and the value is the corresponding
 584     *  TTCN_Logger::Severity.
 585     *
 586     *  For the old categories which now have subcategories, the old keyword
 587     *  is returned as LoggingBitCollection with the corresponding
 588     *  _UNQUALIFIED as the semantic value. The parser will construct the
 589     *  multi-bit value.
 590     *
 591     *  The lexer never returns a token with a Logging_Bits type.
 592     */
 593 LOG_NOTHING     {
 594         yylval.logseverity_val = TTCN_Logger::NOTHING_TO_LOG;
 595         return LoggingBit;
 596         }
 597
 598 ACTION_UNQUALIFIED      {
 599         yylval.logseverity_val = TTCN_Logger::ACTION_UNQUALIFIED;
 600         return LoggingBit;
 601         }
 602 (TTCN_)?ACTION  {
 603         yylval.logseverity_val = TTCN_Logger::ACTION_UNQUALIFIED;
 604         return LoggingBitCollection;
 605         }
 606
 607 DEBUG_ENCDEC    {
 608         yylval.logseverity_val = TTCN_Logger::DEBUG_ENCDEC;
 609         return LoggingBit;
 610         }
 611 DEBUG_TESTPORT  {
 612         yylval.logseverity_val = TTCN_Logger::DEBUG_TESTPORT;
 613         return LoggingBit;
 614         }
 615 DEBUG_UNQUALIFIED               {
 616         yylval.logseverity_val = TTCN_Logger::DEBUG_UNQUALIFIED;
 617         return LoggingBit;
 618         }
 619 (TTCN_)?DEBUG           {
 620         yylval.logseverity_val = TTCN_Logger::DEBUG_UNQUALIFIED;
 621         return LoggingBitCollection;
 622         }
 623
 624 DEFAULTOP_ACTIVATE              {
 625         yylval.logseverity_val = TTCN_Logger::DEFAULTOP_ACTIVATE;
 626         return LoggingBit;
 627         }
 628 DEFAULTOP_DEACTIVATE            {
 629         yylval.logseverity_val = TTCN_Logger::DEFAULTOP_DEACTIVATE;
 630         return LoggingBit;
 631         }
 632 DEFAULTOP_EXIT          {
 633         yylval.logseverity_val = TTCN_Logger::DEFAULTOP_EXIT;
 634         return LoggingBit;
 635         }
 636 DEFAULTOP_UNQUALIFIED           {
 637         yylval.logseverity_val = TTCN_Logger::DEFAULTOP_UNQUALIFIED;
 638         return LoggingBit;
 639         }
 640 (TTCN_)?DEFAULTOP               {
 641         yylval.logseverity_val = TTCN_Logger::DEFAULTOP_UNQUALIFIED;
 642         return LoggingBitCollection;
 643         }
 644
 645 ERROR_UNQUALIFIED       {
 646         yylval.logseverity_val = TTCN_Logger::ERROR_UNQUALIFIED;
 647         return LoggingBit;
 648         }
 649 (TTCN_)?ERROR   {
 650         yylval.logseverity_val = TTCN_Logger::ERROR_UNQUALIFIED;
 651         return LoggingBitCollection;
 652         }
 653
 654 EXECUTOR_COMPONENT              {
 655         yylval.logseverity_val = TTCN_Logger::EXECUTOR_COMPONENT;
 656         return LoggingBit;
 657         }
 658 EXECUTOR_CONFIGDATA     {
 659         yylval.logseverity_val = TTCN_Logger::EXECUTOR_CONFIGDATA;
 660         return LoggingBit;
 661         }
 662 EXECUTOR_EXTCOMMAND             {
 663         yylval.logseverity_val = TTCN_Logger::EXECUTOR_EXTCOMMAND;
 664         return LoggingBit;
 665         }
 666 EXECUTOR_LOGOPTIONS             {
 667         yylval.logseverity_val = TTCN_Logger::EXECUTOR_LOGOPTIONS;
 668         return LoggingBit;
 669         }
 670 EXECUTOR_RUNTIME                {
 671         yylval.logseverity_val = TTCN_Logger::EXECUTOR_RUNTIME;
 672         return LoggingBit;
 673         }
 674 EXECUTOR_UNQUALIFIED            {
 675         yylval.logseverity_val = TTCN_Logger::EXECUTOR_UNQUALIFIED;
 676         return LoggingBit;
 677         }
 678 (TTCN_)?EXECUTOR                {
 679         yylval.logseverity_val = TTCN_Logger::EXECUTOR_UNQUALIFIED;
 680         return LoggingBitCollection;
 681         }
 682
 683 FUNCTION_RND            {
 684         yylval.logseverity_val = TTCN_Logger::FUNCTION_RND;
 685         return LoggingBit;
 686         }
 687 FUNCTION_UNQUALIFIED            {
 688         yylval.logseverity_val = TTCN_Logger::FUNCTION_UNQUALIFIED;
 689         return LoggingBit;
 690         }
 691 (TTCN_)?FUNCTION                {
 692         yylval.logseverity_val = TTCN_Logger::FUNCTION_UNQUALIFIED;
 693         return LoggingBitCollection;
 694         }
 695
 696 MATCHING_DONE           {
 697         yylval.logseverity_val = TTCN_Logger::MATCHING_DONE;
 698         return LoggingBit;
 699         }
 700 MATCHING_MCSUCCESS              {
 701         yylval.logseverity_val = TTCN_Logger::MATCHING_MCSUCCESS;
 702         return LoggingBit;
 703         }
 704 MATCHING_MCUNSUCC               {
 705         yylval.logseverity_val = TTCN_Logger::MATCHING_MCUNSUCC;
 706         return LoggingBit;
 707         }
 708 MATCHING_MMSUCCESS              {
 709         yylval.logseverity_val = TTCN_Logger::MATCHING_MMSUCCESS;
 710         return LoggingBit;
 711         }
 712 MATCHING_MMUNSUCC               {
 713         yylval.logseverity_val = TTCN_Logger::MATCHING_MMUNSUCC;
 714         return LoggingBit;
 715         }
 716 MATCHING_PCSUCCESS              {
 717         yylval.logseverity_val = TTCN_Logger::MATCHING_PCSUCCESS;
 718         return LoggingBit;
 719         }
 720 MATCHING_PCUNSUCC               {
 721         yylval.logseverity_val = TTCN_Logger::MATCHING_PCUNSUCC;
 722         return LoggingBit;
 723         }
 724 MATCHING_PMSUCCESS              {
 725         yylval.logseverity_val = TTCN_Logger::MATCHING_PMSUCCESS;
 726         return LoggingBit;
 727         }
 728 MATCHING_PMUNSUCC               {
 729         yylval.logseverity_val = TTCN_Logger::MATCHING_PMUNSUCC;
 730         return LoggingBit;
 731         }
 732 MATCHING_PROBLEM                {
 733         yylval.logseverity_val = TTCN_Logger::MATCHING_PROBLEM;
 734         return LoggingBit;
 735         }
 736 MATCHING_TIMEOUT                {
 737         yylval.logseverity_val = TTCN_Logger::MATCHING_TIMEOUT;
 738         return LoggingBit;
 739         }
 740 MATCHING_UNQUALIFIED            {
 741         yylval.logseverity_val = TTCN_Logger::MATCHING_UNQUALIFIED;
 742         return LoggingBit;
 743         }
 744 (TTCN_)?MATCHING                {
 745         yylval.logseverity_val = TTCN_Logger::MATCHING_UNQUALIFIED;
 746         return LoggingBitCollection;
 747         }
 748
 749 PARALLEL_PORTCONN               {
 750         yylval.logseverity_val = TTCN_Logger::PARALLEL_PORTCONN;
 751         return LoggingBit;
 752         }
 753 PARALLEL_PORTMAP                {
 754         yylval.logseverity_val = TTCN_Logger::PARALLEL_PORTMAP;
 755         return LoggingBit;
 756         }
 757 PARALLEL_PTC            {
 758         yylval.logseverity_val = TTCN_Logger::PARALLEL_PTC;
 759         return LoggingBit;
 760         }
 761 PARALLEL_UNQUALIFIED            {
 762         yylval.logseverity_val = TTCN_Logger::PARALLEL_UNQUALIFIED;
 763         return LoggingBit;
 764         }
 765 (TTCN_)?PARALLEL                {
 766         yylval.logseverity_val = TTCN_Logger::PARALLEL_UNQUALIFIED;
 767         return LoggingBitCollection;
 768         }
 769
 770 PORTEVENT_DUALRECV              {
 771         yylval.logseverity_val = TTCN_Logger::PORTEVENT_DUALRECV;
 772         return LoggingBit;
 773         }
 774 PORTEVENT_DUALSEND              {
 775         yylval.logseverity_val = TTCN_Logger::PORTEVENT_DUALSEND;
 776         return LoggingBit;
 777         }
 778 PORTEVENT_MCRECV                {
 779         yylval.logseverity_val = TTCN_Logger::PORTEVENT_MCRECV;
 780         return LoggingBit;
 781         }
 782 PORTEVENT_MCSEND                {
 783         yylval.logseverity_val = TTCN_Logger::PORTEVENT_MCSEND;
 784         return LoggingBit;
 785         }
 786 PORTEVENT_MMRECV                {
 787         yylval.logseverity_val = TTCN_Logger::PORTEVENT_MMRECV;
 788         return LoggingBit;
 789         }
 790 PORTEVENT_MMSEND                {
 791         yylval.logseverity_val = TTCN_Logger::PORTEVENT_MMSEND;
 792         return LoggingBit;
 793         }
 794 PORTEVENT_MQUEUE                {
 795         yylval.logseverity_val = TTCN_Logger::PORTEVENT_MQUEUE;
 796         return LoggingBit;
 797         }
 798 PORTEVENT_PCIN          {
 799         yylval.logseverity_val = TTCN_Logger::PORTEVENT_PCIN;
 800         return LoggingBit;
 801         }
 802 PORTEVENT_PCOUT         {
 803         yylval.logseverity_val = TTCN_Logger::PORTEVENT_PCOUT;
 804         return LoggingBit;
 805         }
 806 PORTEVENT_PMIN          {
 807         yylval.logseverity_val = TTCN_Logger::PORTEVENT_PMIN;
 808         return LoggingBit;
 809         }
 810 PORTEVENT_PMOUT         {
 811         yylval.logseverity_val = TTCN_Logger::PORTEVENT_PMOUT;
 812         return LoggingBit;
 813         }
 814 PORTEVENT_PQUEUE                {
 815         yylval.logseverity_val = TTCN_Logger::PORTEVENT_PQUEUE;
 816         return LoggingBit;
 817         }
 818 PORTEVENT_STATE         {
 819         yylval.logseverity_val = TTCN_Logger::PORTEVENT_STATE;
 820         return LoggingBit;
 821         }
 822 PORTEVENT_UNQUALIFIED           {
 823         yylval.logseverity_val = TTCN_Logger::PORTEVENT_UNQUALIFIED;
 824         return LoggingBit;
 825         }
 826 (TTCN_)?PORTEVENT               {
 827         yylval.logseverity_val = TTCN_Logger::PORTEVENT_UNQUALIFIED;
 828         return LoggingBitCollection;
 829         }
 830
 831 STATISTICS_UNQUALIFIED          {
 832         yylval.logseverity_val = TTCN_Logger::STATISTICS_UNQUALIFIED;
 833         return LoggingBit;
 834         }
 835 STATISTICS_VERDICT              {
 836         yylval.logseverity_val = TTCN_Logger::STATISTICS_VERDICT;
 837         return LoggingBit;
 838         }
 839 (TTCN_)?STATISTICS              {
 840         yylval.logseverity_val = TTCN_Logger::STATISTICS_UNQUALIFIED;
 841         return LoggingBitCollection;
 842         }
 843
 844 TESTCASE_FINISH         {
 845         yylval.logseverity_val = TTCN_Logger::TESTCASE_FINISH;
 846         return LoggingBit;
 847         }
 848 TESTCASE_START          {
 849         yylval.logseverity_val = TTCN_Logger::TESTCASE_START;
 850         return LoggingBit;
 851         }
 852 TESTCASE_UNQUALIFIED            {
 853         yylval.logseverity_val = TTCN_Logger::TESTCASE_UNQUALIFIED;
 854         return LoggingBit;
 855         }
 856 (TTCN_)?TESTCASE                {
 857         yylval.logseverity_val = TTCN_Logger::TESTCASE_UNQUALIFIED;
 858         return LoggingBitCollection;
 859         }
 860
 861 TIMEROP_GUARD           {
 862         yylval.logseverity_val = TTCN_Logger::TIMEROP_GUARD;
 863         return LoggingBit;
 864         }
 865 TIMEROP_READ            {
 866         yylval.logseverity_val = TTCN_Logger::TIMEROP_READ;
 867         return LoggingBit;
 868         }
 869 TIMEROP_START           {
 870         yylval.logseverity_val = TTCN_Logger::TIMEROP_START;
 871         return LoggingBit;
 872         }
 873 TIMEROP_STOP            {
 874         yylval.logseverity_val = TTCN_Logger::TIMEROP_STOP;
 875         return LoggingBit;
 876         }
 877 TIMEROP_TIMEOUT         {
 878         yylval.logseverity_val = TTCN_Logger::TIMEROP_TIMEOUT;
 879         return LoggingBit;
 880         }
 881 TIMEROP_UNQUALIFIED             {
 882         yylval.logseverity_val = TTCN_Logger::TIMEROP_UNQUALIFIED;
 883         return LoggingBit;
 884         }
 885 (TTCN_)?TIMEROP         {
 886         yylval.logseverity_val = TTCN_Logger::TIMEROP_UNQUALIFIED;
 887         return LoggingBitCollection;
 888         }
 889
 890 USER_UNQUALIFIED        {
 891         yylval.logseverity_val = TTCN_Logger::USER_UNQUALIFIED;
 892         return LoggingBit;
 893         }
 894 (TTCN_)?USER    {
 895         yylval.logseverity_val = TTCN_Logger::USER_UNQUALIFIED;
 896         return LoggingBitCollection;
 897         }
 898
 899 VERDICTOP_FINAL         {
 900         yylval.logseverity_val = TTCN_Logger::VERDICTOP_FINAL;
 901         return LoggingBit;
 902         }
 903 VERDICTOP_GETVERDICT            {
 904         yylval.logseverity_val = TTCN_Logger::VERDICTOP_GETVERDICT;
 905         return LoggingBit;
 906         }
 907 VERDICTOP_SETVERDICT            {
 908         yylval.logseverity_val = TTCN_Logger::VERDICTOP_SETVERDICT;
 909         return LoggingBit;
 910         }
 911 VERDICTOP_UNQUALIFIED           {
 912         yylval.logseverity_val = TTCN_Logger::VERDICTOP_UNQUALIFIED;
 913         return LoggingBit;
 914         }
 915 (TTCN_)?VERDICTOP               {
 916         yylval.logseverity_val = TTCN_Logger::VERDICTOP_UNQUALIFIED;
 917         return LoggingBitCollection;
 918         }
 919
 920 WARNING_UNQUALIFIED     {
 921         yylval.logseverity_val = TTCN_Logger::WARNING_UNQUALIFIED;
 922         return LoggingBit;
 923         }
 924 (TTCN_)?WARNING {
 925         yylval.logseverity_val = TTCN_Logger::WARNING_UNQUALIFIED;
 926         return LoggingBitCollection;
 927         }
 928
 929 LOG_ALL {
 930         yylval.logseverity_val = TTCN_Logger::LOG_ALL_IMPORTANT;
 931         return LoggingBitCollection;
 932         }
 933
 934 [Tt][Ii][Mm][Ee]        {
 935         yylval.timestamp_value = TTCN_Logger::TIMESTAMP_TIME;
 936         return TimestampValue;
 937         }
 938 [Dd][Aa][Tt][Ee][Tt][Ii][Mm][Ee]        {
 939         yylval.timestamp_value = TTCN_Logger::TIMESTAMP_DATETIME;
 940         return TimestampValue;
 941         }
 942 [Ss][Ee][Cc][Oo][Nn][Dd][Ss]    {
 943         yylval.timestamp_value = TTCN_Logger::TIMESTAMP_SECONDS;
 944         return TimestampValue;
 945         }
 946 [Nn][Oo][Nn][Ee]        {
 947         yylval.source_info_value = TTCN_Logger::SINFO_NONE;
 948         return SourceInfoValue;
 949         }
 950 [Ss][Ii][Nn][Gg][Ll][Ee]        {
 951         yylval.source_info_value = TTCN_Logger::SINFO_SINGLE;
 952         return SourceInfoValue;
 953         }
 954 [Ss][Tt][Aa][Cc][Kk]    {
 955         yylval.source_info_value = TTCN_Logger::SINFO_STACK;
 956         return SourceInfoValue;
 957         }
 958 [Yy][Ee][Ss]            {
 959         yylval.bool_val = TRUE;
 960         return YesNo;
 961         }
 962 [Nn][Oo]                {
 963         yylval.bool_val = FALSE;
 964         return YesNo;
 965         }
 966 [Bb]uffer[Aa]ll  {
 967   yylval.emergency_logging_behaviour_value = TTCN_Logger::BUFFER_ALL;
 968   return EmergencyLoggingBehaviourValue;
 969   }
 970  [Bb]uffer[Mm]asked  {
 971   yylval.emergency_logging_behaviour_value = TTCN_Logger::BUFFER_MASKED;
 972   return EmergencyLoggingBehaviourValue;
 973   }
 974
 975 [Cc]ompact            return Compact;
 976 [Dd]etailed           return Detailed;
 977 [Ss]ub[Cc]ategories   return SubCategories;
 978
 979 [Ee]rror   return Error;
 980
 981 [Ss]top    return Stop;
 982
 983 [Rr]etry   return Retry;
 984
 985 [Dd]elete  return Delete;
 986 }
 987
 988 <SC_PROFILER>
 989 {
 990   [Dd]isable[Pp]rofiler     return DisableProfilerKeyword;
 991   [Dd]isable[Cc]overage     return DisableCoverageKeyword;
 992   [Dd]ata[Bb]ase[Ff]ile     return DatabaseFileKeyword;
 993   [Aa]ggregate[Dd]ata       return AggregateDataKeyword;
 994   [Ss]tatistics[Ff]ile      return StatisticsFileKeyword;
 995   [Dd]isable[Ss]tatistics   return DisableStatisticsKeyword;
 996   [Ss]tatistics[Ff]ilter    return StatisticsFilterKeyword;
 997   [Ss]tart[Aa]utomatically  return StartAutomaticallyKeyword;
 998   [Nn]et[Ll]ine[Tt]imes     return NetLineTimesKeyword;
 999   [Nn]et[Ff]unction[Tt]imes return NetFunctionTimesKeyword;
1000
1001   /* statistics filters */
1002   [Nn]umber[Oo]f[Ll]ines {
1003     yylval.uint_val = TTCN3_Profiler::STATS_NUMBER_OF_LINES;
1004     return ProfilerStatsFlag;
1005   }
1006   [Ll]ine[Dd]ata[Rr]aw {
1007     yylval.uint_val = TTCN3_Profiler::STATS_LINE_DATA_RAW;
1008     return ProfilerStatsFlag;
1009   }
1010   [Ff]unc[Dd]ata[Rr]aw {
1011     yylval.uint_val = TTCN3_Profiler::STATS_FUNC_DATA_RAW;
1012     return ProfilerStatsFlag;
1013   }
1014   [Ll]ine[Aa]vg[Rr]aw {
1015     yylval.uint_val = TTCN3_Profiler::STATS_LINE_AVG_RAW;
1016     return ProfilerStatsFlag;
1017   }
1018   [Ff]unc[Aa]vg[Rr]aw {
1019     yylval.uint_val = TTCN3_Profiler::STATS_FUNC_AVG_RAW;
1020     return ProfilerStatsFlag;
1021   }
1022   [Ll]ine[Tt]imes[Ss]orted[Bb]y[Mm]od {
1023     yylval.uint_val = TTCN3_Profiler::STATS_LINE_TIMES_SORTED_BY_MOD;
1024     return ProfilerStatsFlag;
1025   }
1026   [Ff]unc[Tt]imes[Ss]orted[Bb]y[Mm]od {
1027     yylval.uint_val = TTCN3_Profiler::STATS_FUNC_TIMES_SORTED_BY_MOD;
1028     return ProfilerStatsFlag;
1029   }
1030   [Ll]ine[Tt]imes[Ss]orted[Tt]otal {
1031     yylval.uint_val = TTCN3_Profiler::STATS_LINE_TIMES_SORTED_TOTAL;
1032     return ProfilerStatsFlag;
1033   }
1034   [Ff]unc[Tt]imes[Ss]orted[Tt]otal {
1035     yylval.uint_val = TTCN3_Profiler::STATS_FUNC_TIMES_SORTED_TOTAL;
1036     return ProfilerStatsFlag;
1037   }
1038   [Ll]ine[Cc]ount[Ss]orted[Bb]y[Mm]od {
1039     yylval.uint_val = TTCN3_Profiler::STATS_LINE_COUNT_SORTED_BY_MOD;
1040     return ProfilerStatsFlag;
1041   }
1042   [Ff]unc[Cc]ount[Ss]orted[Bb]y[Mm]od {
1043     yylval.uint_val = TTCN3_Profiler::STATS_FUNC_COUNT_SORTED_BY_MOD;
1044     return ProfilerStatsFlag;
1045   }
1046   [Ll]ine[Cc]ount[Ss]orted[Tt]otal {
1047     yylval.uint_val = TTCN3_Profiler::STATS_LINE_COUNT_SORTED_TOTAL;
1048     return ProfilerStatsFlag;
1049   }
1050   [Ff]unc[Cc]ount[Ss]orted[Tt]otal {
1051     yylval.uint_val = TTCN3_Profiler::STATS_FUNC_COUNT_SORTED_TOTAL;
1052     return ProfilerStatsFlag;
1053   }
1054   [Ll]ine[Aa]vg[Ss]orted[Bb]y[Mm]od {
1055     yylval.uint_val = TTCN3_Profiler::STATS_LINE_AVG_SORTED_BY_MOD;
1056     return ProfilerStatsFlag;
1057   }
1058   [Ff]unc[Aa]vg[Ss]orted[Bb]y[Mm]od {
1059     yylval.uint_val = TTCN3_Profiler::STATS_FUNC_AVG_SORTED_BY_MOD;
1060     return ProfilerStatsFlag;
1061   }
1062   [Ll]ine[Aa]vg[Ss]orted[Tt]otal {
1063     yylval.uint_val = TTCN3_Profiler::STATS_LINE_AVG_SORTED_TOTAL;
1064     return ProfilerStatsFlag;
1065   }
1066   [Ff]unc[Aa]vg[Ss]orted[Tt]otal {
1067     yylval.uint_val = TTCN3_Profiler::STATS_FUNC_AVG_SORTED_TOTAL;
1068     return ProfilerStatsFlag;
1069   }
1070   [Tt]op10[Ll]ine[Tt]imes {
1071     yylval.uint_val = TTCN3_Profiler::STATS_TOP10_LINE_TIMES;
1072     return ProfilerStatsFlag;
1073   }
1074   [Tt]op10[Ff]unc[Tt]imes {
1075     yylval.uint_val = TTCN3_Profiler::STATS_TOP10_FUNC_TIMES;
1076     return ProfilerStatsFlag;
1077   }
1078   [Tt]op10[Ll]ine[Cc]ount {
1079     yylval.uint_val = TTCN3_Profiler::STATS_TOP10_LINE_COUNT;
1080     return ProfilerStatsFlag;
1081   }
1082   [Tt]op10[Ff]unc[Cc]ount {
1083     yylval.uint_val = TTCN3_Profiler::STATS_TOP10_FUNC_COUNT;
1084     return ProfilerStatsFlag;
1085   }
1086   [Tt]op10[Ll]ine[Aa]vg {
1087     yylval.uint_val = TTCN3_Profiler::STATS_TOP10_LINE_AVG;
1088     return ProfilerStatsFlag;
1089   }
1090   [Tt]op10[Ff]unc[Aa]vg {
1091     yylval.uint_val = TTCN3_Profiler::STATS_TOP10_FUNC_AVG;
1092     return ProfilerStatsFlag;
1093   }
1094   [Uu]nused[Ll]ines {
1095     yylval.uint_val = TTCN3_Profiler::STATS_UNUSED_LINES;
1096     return ProfilerStatsFlag;
1097   }
1098   [Uu]nused[Ff]unc {
1099     yylval.uint_val = TTCN3_Profiler::STATS_UNUSED_FUNC;
1100     return ProfilerStatsFlag;
1101   }
1102   [Aa]ll[Rr]aw[Dd]ata {
1103     yylval.uint_val = TTCN3_Profiler::STATS_ALL_RAW_DATA;
1104     return ProfilerStatsFlag;
1105   }
1106   [Ll]ine[Dd]ata[Ss]orted[Bb]y[Mm]od {
1107     yylval.uint_val = TTCN3_Profiler::STATS_LINE_DATA_SORTED_BY_MOD;
1108     return ProfilerStatsFlag;
1109   }
1110   [Ff]unc[Dd]ata[Ss]orted[Bb]y[Mm]od {
1111     yylval.uint_val = TTCN3_Profiler::STATS_FUNC_DATA_SORTED_BY_MOD;
1112     return ProfilerStatsFlag;
1113   }
1114   [Ll]ine[Dd]ata[Ss]orted[Tt]otal {
1115     yylval.uint_val = TTCN3_Profiler::STATS_LINE_DATA_SORTED_TOTAL;
1116     return ProfilerStatsFlag;
1117   }
1118   [Ff]unc[Dd]ata[Ss]orted[Tt]otal {
1119     yylval.uint_val = TTCN3_Profiler::STATS_FUNC_DATA_SORTED_TOTAL;
1120     return ProfilerStatsFlag;
1121   }
1122   [Ll]ine[Dd]ata[Ss]orted {
1123     yylval.uint_val = TTCN3_Profiler::STATS_LINE_DATA_SORTED;
1124     return ProfilerStatsFlag;
1125   }
1126   [Ff]unc[Dd]ata[Ss]orted {
1127     yylval.uint_val = TTCN3_Profiler::STATS_FUNC_DATA_SORTED;
1128     return ProfilerStatsFlag;
1129   }
1130   [Aa]ll[Dd]ata[Ss]orted {
1131     yylval.uint_val = TTCN3_Profiler::STATS_ALL_DATA_SORTED;
1132     return ProfilerStatsFlag;
1133   }
1134   [Tt]op10[Ll]ine[Dd]ata {
1135     yylval.uint_val = TTCN3_Profiler::STATS_TOP10_LINE_DATA;
1136     return ProfilerStatsFlag;
1137   }
1138   [Tt]op10[Ff]unc[Dd]ata {
1139     yylval.uint_val = TTCN3_Profiler::STATS_TOP10_FUNC_DATA;
1140     return ProfilerStatsFlag;
1141   }
1142   [Tt]op10[Aa]ll[Dd]ata {
1143     yylval.uint_val = TTCN3_Profiler::STATS_TOP10_ALL_DATA;
1144     return ProfilerStatsFlag;
1145   }
1146   [Uu]nused[Dd]ata {
1147     yylval.uint_val = TTCN3_Profiler::STATS_UNUSED_DATA;
1148     return ProfilerStatsFlag;
1149   }
1150   [Aa]ll {
1151     yylval.uint_val = TTCN3_Profiler::STATS_ALL;
1152     return ProfilerStatsFlag;
1153   }
1154 }
1155
1156 <SC_EXECUTE>control             return ControlKeyword;
1157
1158 <SC_EXTERNAL_COMMANDS>
1159 {
1160 [Bb]egin[Cc]ontrol[Pp]art       return BeginControlPart;
1161 [Ee]nd[Cc]ontrol[Pp]art         return EndControlPart;
1162 [Bb]egin[Tt]est[Cc]ase          return BeginTestCase;
1163 [Ee]nd[Tt]est[Cc]ase            return EndTestCase;
1164 }
1165
1166 <SC_MAIN_CONTROLLER>
1167 {
1168 [Ll]ocal[Aa]ddress      return LocalAddress;
1169 [Tt][Cc][Pp][Pp]ort     return TCPPort;
1170 [Kk]ill[Tt]imer         return KillTimer;
1171 [Nn]um[Hh][Cc]s         return NumHCs;
1172 [Uu]nix[Ss]ockets[Ee]nabled return UnixSocketEnabled;
1173 [Yy][Ee][Ss]            return YesToken;
1174 [Nn][Oo]                return NoToken;
1175 }
1176
1177 {TTCN3IDENTIFIER}       {
1178     yylval.str_val = mcopystr(yytext);
1179     return Identifier;
1180 }
1181
1182 <SC_MODULE_PARAMETERS>{ASN1LOWERIDENTIFIER}     {
1183     yylval.str_val = mcopystr(yytext);
1184     for (int i = 0; i < yyleng; i++) {
1185         if (yylval.str_val[i] == '-') yylval.str_val[i] = '_';
1186     }
1187     TTCN_warning("In line %d of configuration file: `%s' is not a valid TTCN-3 "
1188         "identifier. Did you mean `%s'?", current_line, yytext, yylval.str_val);
1189     return ASN1LowerIdentifier;
1190 }
1191
1192 <SC_GROUPS,SC_COMPONENTS,SC_MAIN_CONTROLLER>{DNSNAME}|{IPV6} return DNSName;
1193   /* Information is discarded ! */
1194
1195 <SC_STRING2TTCN_COMPONENT>{COMPONENT} {
1196   /* Ignore the component name, just return its number */
1197   size_t len = strlen(yytext);
1198   size_t pos = len - 1;
1199   while(yytext[pos] != '(' && pos != 0) {
1200     --pos;
1201   }
1202   char* comp_num_str = mcopystrn(yytext + pos + 1, len - pos - 1);
1203   yylval.int_val = new int_val_t(comp_num_str);
1204   Free(comp_num_str);
1205   return Number;
1206 }
1207
1208 {MACRO_BOOL} {
1209   if (config_defines != NULL) {
1210     char *macroname = get_macro_id_from_ref(yytext);
1211     size_t macrolen;
1212     const char *macrovalue =
1213       string_map_get_bykey(config_defines, macroname, &macrolen);
1214     if (macrovalue != NULL) {
1215       if (!strcmp(macrovalue, "true")) yylval.bool_val = TRUE;
1216       else if (!strcmp(macrovalue, "false")) yylval.bool_val = FALSE;
1217       else {
1218         config_process_error_f("Macro `%s' cannot be interpreted as boolean "
1219           "value: `%s'", macroname, macrovalue);
1220         yylval.bool_val = FALSE;
1221       }
1222     } else {
1223       config_process_error_f("No macro or environmental variable defined"
1224         " with name `%s'", macroname);
1225       yylval.bool_val = FALSE;
1226     }
1227     Free(macroname);
1228   } else {
1229     config_process_error("Internal error: Macro reference cannot be used in "
1230       "this context.");
1231     yylval.bool_val = FALSE;
1232   }
1233   return BooleanValue;
1234 }
1235
1236 {MACRO_INT} {
1237   if (config_defines != NULL) {
1238     char *macroname = get_macro_id_from_ref(yytext);
1239     size_t macrolen;
1240     const char *macrovalue =
1241       string_map_get_bykey(config_defines, macroname, &macrolen);
1242     if (macrovalue != NULL) {
1243       if (string_is_int(macrovalue, macrolen))
1244         yylval.int_val = new int_val_t(macrovalue);
1245       else {
1246         config_process_error_f("Macro `%s' cannot be interpreted as integer "
1247           "value: `%s'", macroname, macrovalue);
1248         yylval.int_val = new int_val_t((RInt)0);
1249       }
1250     } else {
1251       config_process_error_f("No macro or environmental variable defined"
1252         " with name `%s'", macroname);
1253       yylval.int_val = new int_val_t((RInt)0);
1254     }
1255     Free(macroname);
1256   } else {
1257     config_process_error("Internal error: Macro reference cannot be used in "
1258       "this context.");
1259     yylval.int_val = new int_val_t((RInt)0);
1260   }
1261   return Number;
1262 }
1263
1264 {MACRO_FLOAT} {
1265   if (config_defines != NULL) {
1266     char *macroname = get_macro_id_from_ref(yytext);
1267     size_t macrolen;
1268     const char *macrovalue =
1269       string_map_get_bykey(config_defines, macroname, &macrolen);
1270     if (macrovalue != NULL) {
1271       if (string_is_float(macrovalue, macrolen))
1272         yylval.float_val = atof(macrovalue);
1273       else {
1274         config_process_error_f("Macro `%s' cannot be interpreted as float value: "
1275           "`%s'", macroname, macrovalue);
1276         yylval.float_val = 0.0;
1277       }
1278     } else {
1279       config_process_error_f("No macro or environmental variable defined"
1280         " with name `%s'", macroname);
1281       yylval.float_val = 0.0;
1282     }
1283     Free(macroname);
1284   } else {
1285     config_process_error("Internal error: Macro reference cannot be used in "
1286       "this context.");
1287     yylval.float_val = 0.0;
1288   }
1289   return Float;
1290 }
1291
1292 {MACRO_ID} {
1293   if (config_defines != NULL) {
1294     char *macroname = get_macro_id_from_ref(yytext);
1295     size_t macrolen;
1296     const char *macrovalue =
1297       string_map_get_bykey(config_defines, macroname, &macrolen);
1298     boolean is_asn = FALSE;
1299     if (macrovalue != NULL) {
1300       if (string_is_id(macrovalue, macrolen)) {
1301         yylval.str_val = mcopystr(macrovalue);
1302         for (size_t i = 0; i < macrolen; i++) {
1303           if (yylval.str_val[i]=='-') {
1304             yylval.str_val[i] = '_';
1305             is_asn = TRUE;
1306           }
1307         }
1308         if (is_asn)
1309           TTCN_warning("In line %d of configuration file: `%s' is not a valid"
1310                        " TTCN-3 identifier. Did you mean `%s'?",
1311                        current_line, macrovalue, yylval.str_val);
1312       } else {
1313         config_process_error_f("Macro `%s' cannot be interpreted as identifier: "
1314           "`%s'", macroname, macrovalue);
1315         yylval.str_val = memptystr();
1316       }
1317     } else {
1318       config_process_error_f("No macro or environmental variable defined with "
1319         "name `%s'", macroname);
1320       yylval.str_val = memptystr();
1321     }
1322     Free(macroname);
1323     return is_asn ? ASN1LowerIdentifier : Identifier;
1324   } else {
1325     config_process_error("Internal error: Macro reference cannot be used in "
1326       "this context.");
1327     yylval.str_val = memptystr();
1328     return Identifier;
1329   }
1330 }
1331
1332 {MACRO_CSTR} {
1333   if (config_defines == NULL) {
1334     config_process_error("Internal error: Macro reference cannot be used in "
1335         "this context.");
1336     yylval.charstring_val.n_chars = 0;
1337     yylval.charstring_val.chars_ptr = memptystr();
1338     return Cstring;
1339   }
1340
1341   char *macroname;
1342   if (yytext[1] == '{') macroname = get_macro_id_from_ref(yytext);
1343   else macroname = mcopystr(yytext + 1);
1344   size_t macrolen;
1345   const char *macrovalue = string_map_get_bykey
1346     (config_defines, macroname, &macrolen);
1347
1348   if (macrovalue == NULL) {
1349     config_process_error_f("No macro or environmental variable defined with name "
1350         "`%s'", macroname);
1351     yylval.charstring_val.n_chars=0;
1352     yylval.charstring_val.chars_ptr=memptystr();
1353     Free(macroname);
1354     return Cstring;
1355   }
1356
1357   if (macrolen > 0 && macrovalue[0] == '{') { // structured
1358     main_buffer = YY_CURRENT_BUFFER;
1359     expansion_buffer = yy_scan_string(macrovalue);
1360     yy_switch_to_buffer(expansion_buffer);
1361     Free(macroname);
1362   } else {
1363     yylval.charstring_val.n_chars=macrolen;
1364     yylval.charstring_val.chars_ptr=(char*)Malloc(macrolen+1);
1365     memcpy(yylval.charstring_val.chars_ptr, macrovalue, macrolen+1);
1366     Free(macroname);
1367     return Cstring;
1368   }
1369 }
1370
1371 {MACRO_BSTR} {
1372   if (config_defines != NULL) {
1373     char *macroname = get_macro_id_from_ref(yytext);
1374     size_t macrolen;
1375     const char *macrovalue =
1376       string_map_get_bykey(config_defines, macroname, &macrolen);
1377     if (macrovalue != NULL) {
1378       if (string_is_bstr(macrovalue, macrolen)) {
1379         yylval.bitstring_val.n_bits = macrolen;
1380         int n_bytes = (yylval.bitstring_val.n_bits + 7) / 8;
1381         yylval.bitstring_val.bits_ptr = (unsigned char *)Malloc(n_bytes);
1382         memset(yylval.bitstring_val.bits_ptr, 0, n_bytes);
1383         for (int i = 0; i < yylval.bitstring_val.n_bits; i++)
1384           if (macrovalue[i] == '1')
1385             yylval.bitstring_val.bits_ptr[i/8] |= 1 << (i % 8);
1386       } else {
1387         config_process_error_f("Macro `%s' cannot be interpreted as bitstring "
1388           "value: `%s'", macroname, macrovalue);
1389         yylval.bitstring_val.n_bits = 0;
1390         yylval.bitstring_val.bits_ptr = NULL;
1391       }
1392     } else {
1393       config_process_error_f("No macro or environmental variable defined with "
1394         "name `%s'", macroname);
1395       yylval.bitstring_val.n_bits = 0;
1396       yylval.bitstring_val.bits_ptr = NULL;
1397     }
1398     Free(macroname);
1399   } else {
1400     config_process_error_f("Internal error: Macro reference cannot be used in "
1401       "this context.");
1402     yylval.bitstring_val.n_bits = 0;
1403     yylval.bitstring_val.bits_ptr = NULL;
1404   }
1405   return Bstring;
1406 }
1407
1408 {MACRO_HSTR} {
1409   if (config_defines != NULL) {
1410     char *macroname = get_macro_id_from_ref(yytext);
1411     size_t macrolen;
1412     const char *macrovalue =
1413       string_map_get_bykey(config_defines, macroname, &macrolen);
1414     if (macrovalue != NULL) {
1415       if(string_is_hstr(macrovalue, macrolen)) {
1416         yylval.hexstring_val.n_nibbles = macrolen;
1417         int n_bytes = (yylval.hexstring_val.n_nibbles + 1) / 2;
1418         yylval.hexstring_val.nibbles_ptr = (unsigned char *)Malloc(n_bytes);
1419         memset(yylval.hexstring_val.nibbles_ptr, 0, n_bytes);
1420         for (int i = 0; i < yylval.hexstring_val.n_nibbles; i++) {
1421           unsigned int hex_digit;
1422           sscanf(macrovalue+i, "%1x", &hex_digit);
1423           if(i % 2) yylval.hexstring_val.nibbles_ptr[i/2] |=
1424             (hex_digit << 4);
1425           else yylval.hexstring_val.nibbles_ptr[i/2] |= hex_digit;
1426         }
1427       } else {
1428         config_process_error_f("Macro `%s' cannot be interpreted as hexstring "
1429           "value: `%s'", macroname, macrovalue);
1430         yylval.hexstring_val.n_nibbles = 0;
1431         yylval.hexstring_val.nibbles_ptr = NULL;
1432       }
1433     } else {
1434       config_process_error_f("No macro or environmental variable defined with "
1435         "name `%s'", macroname);
1436       yylval.hexstring_val.n_nibbles = 0;
1437       yylval.hexstring_val.nibbles_ptr = NULL;
1438     }
1439     Free(macroname);
1440   } else {
1441     config_process_error("Internal error: Macro reference cannot be used in "
1442       "this context.");
1443     yylval.hexstring_val.n_nibbles = 0;
1444     yylval.hexstring_val.nibbles_ptr = NULL;
1445   }
1446   return Hstring;
1447 }
1448
1449 {MACRO_OSTR} {
1450   if (config_defines != NULL) {
1451     char *macroname = get_macro_id_from_ref(yytext);
1452     size_t macrolen;
1453     const char *macrovalue =
1454       string_map_get_bykey(config_defines, macroname, &macrolen);
1455     if (macrovalue != NULL) {
1456       if (string_is_ostr(macrovalue, macrolen)) {
1457         yylval.octetstring_val.n_octets = macrolen / 2;
1458         yylval.octetstring_val.octets_ptr = (unsigned char *)
1459           Malloc(yylval.octetstring_val.n_octets);
1460         for (int i = 0; i < yylval.octetstring_val.n_octets; i++) {
1461           unsigned int this_octet;
1462           sscanf(macrovalue+2*i, "%2x", &this_octet);
1463           yylval.octetstring_val.octets_ptr[i] = this_octet;
1464         }
1465       } else {
1466         config_process_error_f("Macro `%s' cannot be interpreted as octetstring "
1467           "value: `%s'", macroname, macrovalue);
1468         yylval.octetstring_val.n_octets = 0;
1469         yylval.octetstring_val.octets_ptr = NULL;
1470       }
1471     } else {
1472       config_process_error_f("No macro or environmental variable defined with "
1473         "name `%s'", macroname);
1474       yylval.octetstring_val.n_octets = 0;
1475       yylval.octetstring_val.octets_ptr = NULL;
1476     }
1477     Free(macroname);
1478   } else {
1479     config_process_error_f("Internal error: Macro reference cannot be used in "
1480       "this context.");
1481     yylval.octetstring_val.n_octets = 0;
1482     yylval.octetstring_val.octets_ptr = NULL;
1483   }
1484   return Ostring;
1485 }
1486
1487 {MACRO_BINARY} {
1488   if (config_defines != NULL) {
1489     char *macroname = get_macro_id_from_ref(yytext);
1490     size_t macrolen;
1491     const char *macrovalue =
1492       string_map_get_bykey(config_defines, macroname, &macrolen);
1493     if (macrovalue != NULL) {
1494       yylval.octetstring_val.n_octets=macrolen;
1495       yylval.octetstring_val.octets_ptr = (unsigned char*)Malloc(macrolen);
1496       memcpy(yylval.octetstring_val.octets_ptr, macrovalue, macrolen);
1497     }
1498     else {
1499       config_process_error_f("No macro or environmental variable defined with "
1500         "name `%s'", macroname);
1501       yylval.octetstring_val.n_octets = 0;
1502       yylval.octetstring_val.octets_ptr = NULL;
1503     }
1504     Free(macroname);
1505   } else {
1506     config_process_error("Internal error: Macro reference cannot be used in "
1507       "this context.");
1508     yylval.octetstring_val.n_octets = 0;
1509     yylval.octetstring_val.octets_ptr = NULL;
1510   }
1511   return Ostring;
1512 }
1513
1514 {MACRO_HOSTNAME} {
1515   if (config_defines != NULL) {
1516     char *macroname = get_macro_id_from_ref(yytext);
1517     size_t macrolen;
1518     const char *macrovalue =
1519       string_map_get_bykey(config_defines, macroname, &macrolen);
1520     if (macrovalue != NULL) {
1521       if (!string_is_hostname(macrovalue, macrolen)) {
1522         config_process_error_f("Macro `%s' cannot be interpreted as host name: "
1523           "`%s'", macroname, macrovalue);
1524       }
1525     } else {
1526       config_process_error_f("No macro or environmental variable defined with "
1527         "name `%s'", macroname);
1528     }
1529     Free(macroname);
1530   } else {
1531     config_process_error("Internal error: Macro reference cannot be used in "
1532       "this context.");
1533   }
1534   return DNSName;
1535 }
1536
1537 ":="|"="    return AssignmentChar;
1538 "&="        return ConcatChar;
1539
1540 <<EOF>> {
1541    if (expansion_buffer) {
1542      yy_switch_to_buffer(main_buffer);
1543      yy_delete_buffer(expansion_buffer);
1544      expansion_buffer = NULL;
1545    } else {
1546      if (include_chain->size() > 1) {
1547        yy_delete_buffer(YY_CURRENT_BUFFER);
1548        fclose(include_chain->back().fp);
1549        include_chain->pop_back();
1550        yy_switch_to_buffer(include_chain->back().buffer_state);
1551        current_line = include_chain->back().line_number;
1552        BEGIN(SC_ORDERED_INCLUDE);
1553      } else {
1554        yyterminate();
1555        return EOF;
1556      }
1557    }
1558  }
1559
1560
1561
1562 .           return yytext[0];
1563
1564
1565 %%
1566
1567 void reset_config_process_lex(const char* fname)
1568 {
1569   if (!include_chain) {
1570     include_chain = new std::deque<IncludeElem<YY_BUFFER_STATE> >();
1571   }
1572   BEGIN(INITIAL);
1573   current_line = 1;
1574   if (fname) {
1575     include_chain->push_back(IncludeElem<YY_BUFFER_STATE>(std::string(fname), config_process_in));
1576   }
1577 }
1578
1579 void config_process_close() {
1580   delete include_chain;
1581   include_chain = NULL;
1582 }
1583
1584 int config_process_get_current_line()
1585 {
1586   return current_line;
1587 }
1588
1589