core/config_process.l

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