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_USER      {
 632         yylval.logseverity_val = TTCN_Logger::DEBUG_USER;
 633         return LoggingBit;
 634         }
 635 DEBUG_FRAMEWORK {
 636         yylval.logseverity_val = TTCN_Logger::DEBUG_FRAMEWORK;
 637         return LoggingBit;
 638         }
 639 DEBUG_UNQUALIFIED               {
 640         yylval.logseverity_val = TTCN_Logger::DEBUG_UNQUALIFIED;
 641         return LoggingBit;
 642         }
 643 (TTCN_)?DEBUG           {
 644         yylval.logseverity_val = TTCN_Logger::DEBUG_UNQUALIFIED;
 645         return LoggingBitCollection;
 646         }
 647
 648 DEFAULTOP_ACTIVATE              {
 649         yylval.logseverity_val = TTCN_Logger::DEFAULTOP_ACTIVATE;
 650         return LoggingBit;
 651         }
 652 DEFAULTOP_DEACTIVATE            {
 653         yylval.logseverity_val = TTCN_Logger::DEFAULTOP_DEACTIVATE;
 654         return LoggingBit;
 655         }
 656 DEFAULTOP_EXIT          {
 657         yylval.logseverity_val = TTCN_Logger::DEFAULTOP_EXIT;
 658         return LoggingBit;
 659         }
 660 DEFAULTOP_UNQUALIFIED           {
 661         yylval.logseverity_val = TTCN_Logger::DEFAULTOP_UNQUALIFIED;
 662         return LoggingBit;
 663         }
 664 (TTCN_)?DEFAULTOP               {
 665         yylval.logseverity_val = TTCN_Logger::DEFAULTOP_UNQUALIFIED;
 666         return LoggingBitCollection;
 667         }
 668
 669 ERROR_UNQUALIFIED       {
 670         yylval.logseverity_val = TTCN_Logger::ERROR_UNQUALIFIED;
 671         return LoggingBit;
 672         }
 673 (TTCN_)?ERROR   {
 674         yylval.logseverity_val = TTCN_Logger::ERROR_UNQUALIFIED;
 675         return LoggingBitCollection;
 676         }
 677
 678 EXECUTOR_COMPONENT              {
 679         yylval.logseverity_val = TTCN_Logger::EXECUTOR_COMPONENT;
 680         return LoggingBit;
 681         }
 682 EXECUTOR_CONFIGDATA     {
 683         yylval.logseverity_val = TTCN_Logger::EXECUTOR_CONFIGDATA;
 684         return LoggingBit;
 685         }
 686 EXECUTOR_EXTCOMMAND             {
 687         yylval.logseverity_val = TTCN_Logger::EXECUTOR_EXTCOMMAND;
 688         return LoggingBit;
 689         }
 690 EXECUTOR_LOGOPTIONS             {
 691         yylval.logseverity_val = TTCN_Logger::EXECUTOR_LOGOPTIONS;
 692         return LoggingBit;
 693         }
 694 EXECUTOR_RUNTIME                {
 695         yylval.logseverity_val = TTCN_Logger::EXECUTOR_RUNTIME;
 696         return LoggingBit;
 697         }
 698 EXECUTOR_UNQUALIFIED            {
 699         yylval.logseverity_val = TTCN_Logger::EXECUTOR_UNQUALIFIED;
 700         return LoggingBit;
 701         }
 702 (TTCN_)?EXECUTOR                {
 703         yylval.logseverity_val = TTCN_Logger::EXECUTOR_UNQUALIFIED;
 704         return LoggingBitCollection;
 705         }
 706
 707 FUNCTION_RND            {
 708         yylval.logseverity_val = TTCN_Logger::FUNCTION_RND;
 709         return LoggingBit;
 710         }
 711 FUNCTION_UNQUALIFIED            {
 712         yylval.logseverity_val = TTCN_Logger::FUNCTION_UNQUALIFIED;
 713         return LoggingBit;
 714         }
 715 (TTCN_)?FUNCTION                {
 716         yylval.logseverity_val = TTCN_Logger::FUNCTION_UNQUALIFIED;
 717         return LoggingBitCollection;
 718         }
 719
 720 MATCHING_DONE           {
 721         yylval.logseverity_val = TTCN_Logger::MATCHING_DONE;
 722         return LoggingBit;
 723         }
 724 MATCHING_MCSUCCESS              {
 725         yylval.logseverity_val = TTCN_Logger::MATCHING_MCSUCCESS;
 726         return LoggingBit;
 727         }
 728 MATCHING_MCUNSUCC               {
 729         yylval.logseverity_val = TTCN_Logger::MATCHING_MCUNSUCC;
 730         return LoggingBit;
 731         }
 732 MATCHING_MMSUCCESS              {
 733         yylval.logseverity_val = TTCN_Logger::MATCHING_MMSUCCESS;
 734         return LoggingBit;
 735         }
 736 MATCHING_MMUNSUCC               {
 737         yylval.logseverity_val = TTCN_Logger::MATCHING_MMUNSUCC;
 738         return LoggingBit;
 739         }
 740 MATCHING_PCSUCCESS              {
 741         yylval.logseverity_val = TTCN_Logger::MATCHING_PCSUCCESS;
 742         return LoggingBit;
 743         }
 744 MATCHING_PCUNSUCC               {
 745         yylval.logseverity_val = TTCN_Logger::MATCHING_PCUNSUCC;
 746         return LoggingBit;
 747         }
 748 MATCHING_PMSUCCESS              {
 749         yylval.logseverity_val = TTCN_Logger::MATCHING_PMSUCCESS;
 750         return LoggingBit;
 751         }
 752 MATCHING_PMUNSUCC               {
 753         yylval.logseverity_val = TTCN_Logger::MATCHING_PMUNSUCC;
 754         return LoggingBit;
 755         }
 756 MATCHING_PROBLEM                {
 757         yylval.logseverity_val = TTCN_Logger::MATCHING_PROBLEM;
 758         return LoggingBit;
 759         }
 760 MATCHING_TIMEOUT                {
 761         yylval.logseverity_val = TTCN_Logger::MATCHING_TIMEOUT;
 762         return LoggingBit;
 763         }
 764 MATCHING_UNQUALIFIED            {
 765         yylval.logseverity_val = TTCN_Logger::MATCHING_UNQUALIFIED;
 766         return LoggingBit;
 767         }
 768 (TTCN_)?MATCHING                {
 769         yylval.logseverity_val = TTCN_Logger::MATCHING_UNQUALIFIED;
 770         return LoggingBitCollection;
 771         }
 772
 773 PARALLEL_PORTCONN               {
 774         yylval.logseverity_val = TTCN_Logger::PARALLEL_PORTCONN;
 775         return LoggingBit;
 776         }
 777 PARALLEL_PORTMAP                {
 778         yylval.logseverity_val = TTCN_Logger::PARALLEL_PORTMAP;
 779         return LoggingBit;
 780         }
 781 PARALLEL_PTC            {
 782         yylval.logseverity_val = TTCN_Logger::PARALLEL_PTC;
 783         return LoggingBit;
 784         }
 785 PARALLEL_UNQUALIFIED            {
 786         yylval.logseverity_val = TTCN_Logger::PARALLEL_UNQUALIFIED;
 787         return LoggingBit;
 788         }
 789 (TTCN_)?PARALLEL                {
 790         yylval.logseverity_val = TTCN_Logger::PARALLEL_UNQUALIFIED;
 791         return LoggingBitCollection;
 792         }
 793
 794 PORTEVENT_DUALRECV              {
 795         yylval.logseverity_val = TTCN_Logger::PORTEVENT_DUALRECV;
 796         return LoggingBit;
 797         }
 798 PORTEVENT_DUALSEND              {
 799         yylval.logseverity_val = TTCN_Logger::PORTEVENT_DUALSEND;
 800         return LoggingBit;
 801         }
 802 PORTEVENT_MCRECV                {
 803         yylval.logseverity_val = TTCN_Logger::PORTEVENT_MCRECV;
 804         return LoggingBit;
 805         }
 806 PORTEVENT_MCSEND                {
 807         yylval.logseverity_val = TTCN_Logger::PORTEVENT_MCSEND;
 808         return LoggingBit;
 809         }
 810 PORTEVENT_MMRECV                {
 811         yylval.logseverity_val = TTCN_Logger::PORTEVENT_MMRECV;
 812         return LoggingBit;
 813         }
 814 PORTEVENT_MMSEND                {
 815         yylval.logseverity_val = TTCN_Logger::PORTEVENT_MMSEND;
 816         return LoggingBit;
 817         }
 818 PORTEVENT_MQUEUE                {
 819         yylval.logseverity_val = TTCN_Logger::PORTEVENT_MQUEUE;
 820         return LoggingBit;
 821         }
 822 PORTEVENT_PCIN          {
 823         yylval.logseverity_val = TTCN_Logger::PORTEVENT_PCIN;
 824         return LoggingBit;
 825         }
 826 PORTEVENT_PCOUT         {
 827         yylval.logseverity_val = TTCN_Logger::PORTEVENT_PCOUT;
 828         return LoggingBit;
 829         }
 830 PORTEVENT_PMIN          {
 831         yylval.logseverity_val = TTCN_Logger::PORTEVENT_PMIN;
 832         return LoggingBit;
 833         }
 834 PORTEVENT_PMOUT         {
 835         yylval.logseverity_val = TTCN_Logger::PORTEVENT_PMOUT;
 836         return LoggingBit;
 837         }
 838 PORTEVENT_PQUEUE                {
 839         yylval.logseverity_val = TTCN_Logger::PORTEVENT_PQUEUE;
 840         return LoggingBit;
 841         }
 842 PORTEVENT_STATE         {
 843         yylval.logseverity_val = TTCN_Logger::PORTEVENT_STATE;
 844         return LoggingBit;
 845         }
 846 PORTEVENT_UNQUALIFIED           {
 847         yylval.logseverity_val = TTCN_Logger::PORTEVENT_UNQUALIFIED;
 848         return LoggingBit;
 849         }
 850 (TTCN_)?PORTEVENT               {
 851         yylval.logseverity_val = TTCN_Logger::PORTEVENT_UNQUALIFIED;
 852         return LoggingBitCollection;
 853         }
 854
 855 STATISTICS_UNQUALIFIED          {
 856         yylval.logseverity_val = TTCN_Logger::STATISTICS_UNQUALIFIED;
 857         return LoggingBit;
 858         }
 859 STATISTICS_VERDICT              {
 860         yylval.logseverity_val = TTCN_Logger::STATISTICS_VERDICT;
 861         return LoggingBit;
 862         }
 863 (TTCN_)?STATISTICS              {
 864         yylval.logseverity_val = TTCN_Logger::STATISTICS_UNQUALIFIED;
 865         return LoggingBitCollection;
 866         }
 867
 868 TESTCASE_FINISH         {
 869         yylval.logseverity_val = TTCN_Logger::TESTCASE_FINISH;
 870         return LoggingBit;
 871         }
 872 TESTCASE_START          {
 873         yylval.logseverity_val = TTCN_Logger::TESTCASE_START;
 874         return LoggingBit;
 875         }
 876 TESTCASE_UNQUALIFIED            {
 877         yylval.logseverity_val = TTCN_Logger::TESTCASE_UNQUALIFIED;
 878         return LoggingBit;
 879         }
 880 (TTCN_)?TESTCASE                {
 881         yylval.logseverity_val = TTCN_Logger::TESTCASE_UNQUALIFIED;
 882         return LoggingBitCollection;
 883         }
 884
 885 TIMEROP_GUARD           {
 886         yylval.logseverity_val = TTCN_Logger::TIMEROP_GUARD;
 887         return LoggingBit;
 888         }
 889 TIMEROP_READ            {
 890         yylval.logseverity_val = TTCN_Logger::TIMEROP_READ;
 891         return LoggingBit;
 892         }
 893 TIMEROP_START           {
 894         yylval.logseverity_val = TTCN_Logger::TIMEROP_START;
 895         return LoggingBit;
 896         }
 897 TIMEROP_STOP            {
 898         yylval.logseverity_val = TTCN_Logger::TIMEROP_STOP;
 899         return LoggingBit;
 900         }
 901 TIMEROP_TIMEOUT         {
 902         yylval.logseverity_val = TTCN_Logger::TIMEROP_TIMEOUT;
 903         return LoggingBit;
 904         }
 905 TIMEROP_UNQUALIFIED             {
 906         yylval.logseverity_val = TTCN_Logger::TIMEROP_UNQUALIFIED;
 907         return LoggingBit;
 908         }
 909 (TTCN_)?TIMEROP         {
 910         yylval.logseverity_val = TTCN_Logger::TIMEROP_UNQUALIFIED;
 911         return LoggingBitCollection;
 912         }
 913
 914 USER_UNQUALIFIED        {
 915         yylval.logseverity_val = TTCN_Logger::USER_UNQUALIFIED;
 916         return LoggingBit;
 917         }
 918 (TTCN_)?USER    {
 919         yylval.logseverity_val = TTCN_Logger::USER_UNQUALIFIED;
 920         return LoggingBitCollection;
 921         }
 922
 923 VERDICTOP_FINAL         {
 924         yylval.logseverity_val = TTCN_Logger::VERDICTOP_FINAL;
 925         return LoggingBit;
 926         }
 927 VERDICTOP_GETVERDICT            {
 928         yylval.logseverity_val = TTCN_Logger::VERDICTOP_GETVERDICT;
 929         return LoggingBit;
 930         }
 931 VERDICTOP_SETVERDICT            {
 932         yylval.logseverity_val = TTCN_Logger::VERDICTOP_SETVERDICT;
 933         return LoggingBit;
 934         }
 935 VERDICTOP_UNQUALIFIED           {
 936         yylval.logseverity_val = TTCN_Logger::VERDICTOP_UNQUALIFIED;
 937         return LoggingBit;
 938         }
 939 (TTCN_)?VERDICTOP               {
 940         yylval.logseverity_val = TTCN_Logger::VERDICTOP_UNQUALIFIED;
 941         return LoggingBitCollection;
 942         }
 943
 944 WARNING_UNQUALIFIED     {
 945         yylval.logseverity_val = TTCN_Logger::WARNING_UNQUALIFIED;
 946         return LoggingBit;
 947         }
 948 (TTCN_)?WARNING {
 949         yylval.logseverity_val = TTCN_Logger::WARNING_UNQUALIFIED;
 950         return LoggingBitCollection;
 951         }
 952
 953 LOG_ALL {
 954         yylval.logseverity_val = TTCN_Logger::LOG_ALL_IMPORTANT;
 955         return LoggingBitCollection;
 956         }
 957
 958 [Tt][Ii][Mm][Ee]        {
 959         yylval.timestamp_value = TTCN_Logger::TIMESTAMP_TIME;
 960         return TimestampValue;
 961         }
 962 [Dd][Aa][Tt][Ee][Tt][Ii][Mm][Ee]        {
 963         yylval.timestamp_value = TTCN_Logger::TIMESTAMP_DATETIME;
 964         return TimestampValue;
 965         }
 966 [Ss][Ee][Cc][Oo][Nn][Dd][Ss]    {
 967         yylval.timestamp_value = TTCN_Logger::TIMESTAMP_SECONDS;
 968         return TimestampValue;
 969         }
 970 [Nn][Oo][Nn][Ee]        {
 971         yylval.source_info_value = TTCN_Logger::SINFO_NONE;
 972         return SourceInfoValue;
 973         }
 974 [Ss][Ii][Nn][Gg][Ll][Ee]        {
 975         yylval.source_info_value = TTCN_Logger::SINFO_SINGLE;
 976         return SourceInfoValue;
 977         }
 978 [Ss][Tt][Aa][Cc][Kk]    {
 979         yylval.source_info_value = TTCN_Logger::SINFO_STACK;
 980         return SourceInfoValue;
 981         }
 982 [Yy][Ee][Ss]            {
 983         yylval.bool_val = TRUE;
 984         return YesNo;
 985         }
 986 [Nn][Oo]                {
 987         yylval.bool_val = FALSE;
 988         return YesNo;
 989         }
 990 [Bb]uffer[Aa]ll  {
 991   yylval.emergency_logging_behaviour_value = TTCN_Logger::BUFFER_ALL;
 992   return EmergencyLoggingBehaviourValue;
 993   }
 994  [Bb]uffer[Mm]asked  {
 995   yylval.emergency_logging_behaviour_value = TTCN_Logger::BUFFER_MASKED;
 996   return EmergencyLoggingBehaviourValue;
 997   }
 998
 999 [Cc]ompact            return Compact;
1000 [Dd]etailed           return Detailed;
1001 [Ss]ub[Cc]ategories   return SubCategories;
1002
1003 [Ee]rror   return Error;
1004
1005 [Ss]top    return Stop;
1006
1007 [Rr]etry   return Retry;
1008
1009 [Dd]elete  return Delete;
1010 }
1011
1012 <SC_PROFILER>
1013 {
1014   [Dd]isable[Pp]rofiler     return DisableProfilerKeyword;
1015   [Dd]isable[Cc]overage     return DisableCoverageKeyword;
1016   [Dd]ata[Bb]ase[Ff]ile     return DatabaseFileKeyword;
1017   [Aa]ggregate[Dd]ata       return AggregateDataKeyword;
1018   [Ss]tatistics[Ff]ile      return StatisticsFileKeyword;
1019   [Dd]isable[Ss]tatistics   return DisableStatisticsKeyword;
1020   [Ss]tatistics[Ff]ilter    return StatisticsFilterKeyword;
1021   [Ss]tart[Aa]utomatically  return StartAutomaticallyKeyword;
1022   [Nn]et[Ll]ine[Tt]imes     return NetLineTimesKeyword;
1023   [Nn]et[Ff]unction[Tt]imes return NetFunctionTimesKeyword;
1024
1025   /* statistics filters */
1026   [Nn]umber[Oo]f[Ll]ines {
1027     yylval.uint_val = Profiler_Tools::STATS_NUMBER_OF_LINES;
1028     return ProfilerStatsFlag;
1029   }
1030   [Ll]ine[Dd]ata[Rr]aw {
1031     yylval.uint_val = Profiler_Tools::STATS_LINE_DATA_RAW;
1032     return ProfilerStatsFlag;
1033   }
1034   [Ff]unc[Dd]ata[Rr]aw {
1035     yylval.uint_val = Profiler_Tools::STATS_FUNC_DATA_RAW;
1036     return ProfilerStatsFlag;
1037   }
1038   [Ll]ine[Aa]vg[Rr]aw {
1039     yylval.uint_val = Profiler_Tools::STATS_LINE_AVG_RAW;
1040     return ProfilerStatsFlag;
1041   }
1042   [Ff]unc[Aa]vg[Rr]aw {
1043     yylval.uint_val = Profiler_Tools::STATS_FUNC_AVG_RAW;
1044     return ProfilerStatsFlag;
1045   }
1046   [Ll]ine[Tt]imes[Ss]orted[Bb]y[Mm]od {
1047     yylval.uint_val = Profiler_Tools::STATS_LINE_TIMES_SORTED_BY_MOD;
1048     return ProfilerStatsFlag;
1049   }
1050   [Ff]unc[Tt]imes[Ss]orted[Bb]y[Mm]od {
1051     yylval.uint_val = Profiler_Tools::STATS_FUNC_TIMES_SORTED_BY_MOD;
1052     return ProfilerStatsFlag;
1053   }
1054   [Ll]ine[Tt]imes[Ss]orted[Tt]otal {
1055     yylval.uint_val = Profiler_Tools::STATS_LINE_TIMES_SORTED_TOTAL;
1056     return ProfilerStatsFlag;
1057   }
1058   [Ff]unc[Tt]imes[Ss]orted[Tt]otal {
1059     yylval.uint_val = Profiler_Tools::STATS_FUNC_TIMES_SORTED_TOTAL;
1060     return ProfilerStatsFlag;
1061   }
1062   [Ll]ine[Cc]ount[Ss]orted[Bb]y[Mm]od {
1063     yylval.uint_val = Profiler_Tools::STATS_LINE_COUNT_SORTED_BY_MOD;
1064     return ProfilerStatsFlag;
1065   }
1066   [Ff]unc[Cc]ount[Ss]orted[Bb]y[Mm]od {
1067     yylval.uint_val = Profiler_Tools::STATS_FUNC_COUNT_SORTED_BY_MOD;
1068     return ProfilerStatsFlag;
1069   }
1070   [Ll]ine[Cc]ount[Ss]orted[Tt]otal {
1071     yylval.uint_val = Profiler_Tools::STATS_LINE_COUNT_SORTED_TOTAL;
1072     return ProfilerStatsFlag;
1073   }
1074   [Ff]unc[Cc]ount[Ss]orted[Tt]otal {
1075     yylval.uint_val = Profiler_Tools::STATS_FUNC_COUNT_SORTED_TOTAL;
1076     return ProfilerStatsFlag;
1077   }
1078   [Ll]ine[Aa]vg[Ss]orted[Bb]y[Mm]od {
1079     yylval.uint_val = Profiler_Tools::STATS_LINE_AVG_SORTED_BY_MOD;
1080     return ProfilerStatsFlag;
1081   }
1082   [Ff]unc[Aa]vg[Ss]orted[Bb]y[Mm]od {
1083     yylval.uint_val = Profiler_Tools::STATS_FUNC_AVG_SORTED_BY_MOD;
1084     return ProfilerStatsFlag;
1085   }
1086   [Ll]ine[Aa]vg[Ss]orted[Tt]otal {
1087     yylval.uint_val = Profiler_Tools::STATS_LINE_AVG_SORTED_TOTAL;
1088     return ProfilerStatsFlag;
1089   }
1090   [Ff]unc[Aa]vg[Ss]orted[Tt]otal {
1091     yylval.uint_val = Profiler_Tools::STATS_FUNC_AVG_SORTED_TOTAL;
1092     return ProfilerStatsFlag;
1093   }
1094   [Tt]op10[Ll]ine[Tt]imes {
1095     yylval.uint_val = Profiler_Tools::STATS_TOP10_LINE_TIMES;
1096     return ProfilerStatsFlag;
1097   }
1098   [Tt]op10[Ff]unc[Tt]imes {
1099     yylval.uint_val = Profiler_Tools::STATS_TOP10_FUNC_TIMES;
1100     return ProfilerStatsFlag;
1101   }
1102   [Tt]op10[Ll]ine[Cc]ount {
1103     yylval.uint_val = Profiler_Tools::STATS_TOP10_LINE_COUNT;
1104     return ProfilerStatsFlag;
1105   }
1106   [Tt]op10[Ff]unc[Cc]ount {
1107     yylval.uint_val = Profiler_Tools::STATS_TOP10_FUNC_COUNT;
1108     return ProfilerStatsFlag;
1109   }
1110   [Tt]op10[Ll]ine[Aa]vg {
1111     yylval.uint_val = Profiler_Tools::STATS_TOP10_LINE_AVG;
1112     return ProfilerStatsFlag;
1113   }
1114   [Tt]op10[Ff]unc[Aa]vg {
1115     yylval.uint_val = Profiler_Tools::STATS_TOP10_FUNC_AVG;
1116     return ProfilerStatsFlag;
1117   }
1118   [Uu]nused[Ll]ines {
1119     yylval.uint_val = Profiler_Tools::STATS_UNUSED_LINES;
1120     return ProfilerStatsFlag;
1121   }
1122   [Uu]nused[Ff]unc {
1123     yylval.uint_val = Profiler_Tools::STATS_UNUSED_FUNC;
1124     return ProfilerStatsFlag;
1125   }
1126   [Aa]ll[Rr]aw[Dd]ata {
1127     yylval.uint_val = Profiler_Tools::STATS_ALL_RAW_DATA;
1128     return ProfilerStatsFlag;
1129   }
1130   [Ll]ine[Dd]ata[Ss]orted[Bb]y[Mm]od {
1131     yylval.uint_val = Profiler_Tools::STATS_LINE_DATA_SORTED_BY_MOD;
1132     return ProfilerStatsFlag;
1133   }
1134   [Ff]unc[Dd]ata[Ss]orted[Bb]y[Mm]od {
1135     yylval.uint_val = Profiler_Tools::STATS_FUNC_DATA_SORTED_BY_MOD;
1136     return ProfilerStatsFlag;
1137   }
1138   [Ll]ine[Dd]ata[Ss]orted[Tt]otal {
1139     yylval.uint_val = Profiler_Tools::STATS_LINE_DATA_SORTED_TOTAL;
1140     return ProfilerStatsFlag;
1141   }
1142   [Ff]unc[Dd]ata[Ss]orted[Tt]otal {
1143     yylval.uint_val = Profiler_Tools::STATS_FUNC_DATA_SORTED_TOTAL;
1144     return ProfilerStatsFlag;
1145   }
1146   [Ll]ine[Dd]ata[Ss]orted {
1147     yylval.uint_val = Profiler_Tools::STATS_LINE_DATA_SORTED;
1148     return ProfilerStatsFlag;
1149   }
1150   [Ff]unc[Dd]ata[Ss]orted {
1151     yylval.uint_val = Profiler_Tools::STATS_FUNC_DATA_SORTED;
1152     return ProfilerStatsFlag;
1153   }
1154   [Aa]ll[Dd]ata[Ss]orted {
1155     yylval.uint_val = Profiler_Tools::STATS_ALL_DATA_SORTED;
1156     return ProfilerStatsFlag;
1157   }
1158   [Tt]op10[Ll]ine[Dd]ata {
1159     yylval.uint_val = Profiler_Tools::STATS_TOP10_LINE_DATA;
1160     return ProfilerStatsFlag;
1161   }
1162   [Tt]op10[Ff]unc[Dd]ata {
1163     yylval.uint_val = Profiler_Tools::STATS_TOP10_FUNC_DATA;
1164     return ProfilerStatsFlag;
1165   }
1166   [Tt]op10[Aa]ll[Dd]ata {
1167     yylval.uint_val = Profiler_Tools::STATS_TOP10_ALL_DATA;
1168     return ProfilerStatsFlag;
1169   }
1170   [Uu]nused[Dd]ata {
1171     yylval.uint_val = Profiler_Tools::STATS_UNUSED_DATA;
1172     return ProfilerStatsFlag;
1173   }
1174   [Aa]ll {
1175     yylval.uint_val = Profiler_Tools::STATS_ALL;
1176     return ProfilerStatsFlag;
1177   }
1178 }
1179
1180 <SC_EXECUTE>control             return ControlKeyword;
1181
1182 <SC_EXTERNAL_COMMANDS>
1183 {
1184 [Bb]egin[Cc]ontrol[Pp]art       return BeginControlPart;
1185 [Ee]nd[Cc]ontrol[Pp]art         return EndControlPart;
1186 [Bb]egin[Tt]est[Cc]ase          return BeginTestCase;
1187 [Ee]nd[Tt]est[Cc]ase            return EndTestCase;
1188 }
1189
1190 <SC_MAIN_CONTROLLER>
1191 {
1192 [Ll]ocal[Aa]ddress      return LocalAddress;
1193 [Tt][Cc][Pp][Pp]ort     return TCPPort;
1194 [Kk]ill[Tt]imer         return KillTimer;
1195 [Nn]um[Hh][Cc]s         return NumHCs;
1196 [Uu]nix[Ss]ockets[Ee]nabled return UnixSocketEnabled;
1197 [Yy][Ee][Ss]            return YesToken;
1198 [Nn][Oo]                return NoToken;
1199 }
1200
1201 {TTCN3IDENTIFIER}       {
1202     yylval.str_val = mcopystr(yytext);
1203     return Identifier;
1204 }
1205
1206 <SC_MODULE_PARAMETERS>{ASN1LOWERIDENTIFIER}     {
1207     yylval.str_val = mcopystr(yytext);
1208     for (size_t i = 0; i < yyleng; i++) {
1209         if (yylval.str_val[i] == '-') yylval.str_val[i] = '_';
1210     }
1211     TTCN_warning("In line %d of configuration file: `%s' is not a valid TTCN-3 "
1212         "identifier. Did you mean `%s'?", current_line, yytext, yylval.str_val);
1213     return ASN1LowerIdentifier;
1214 }
1215
1216 <SC_GROUPS,SC_COMPONENTS,SC_MAIN_CONTROLLER>{DNSNAME}|{IPV6} return DNSName;
1217   /* Information is discarded ! */
1218
1219 <SC_STRING2TTCN_COMPONENT>{COMPONENT} {
1220   /* Ignore the component name, just return its number */
1221   size_t len = strlen(yytext);
1222   size_t pos = len - 1;
1223   while(yytext[pos] != '(' && pos != 0) {
1224     --pos;
1225   }
1226   char* comp_num_str = mcopystrn(yytext + pos + 1, len - pos - 1);
1227   yylval.int_val = new int_val_t(comp_num_str);
1228   Free(comp_num_str);
1229   return MPNumber;
1230 }
1231
1232 {MACRO_BOOL} {
1233   if (config_defines != NULL) {
1234     char *macroname = get_macro_id_from_ref(yytext);
1235     size_t macrolen;
1236     const char *macrovalue =
1237       string_map_get_bykey(config_defines, macroname, &macrolen);
1238     if (macrovalue != NULL) {
1239       if (!strcmp(macrovalue, "true")) yylval.bool_val = TRUE;
1240       else if (!strcmp(macrovalue, "false")) yylval.bool_val = FALSE;
1241       else {
1242         config_process_error_f("Macro `%s' cannot be interpreted as boolean "
1243           "value: `%s'", macroname, macrovalue);
1244         yylval.bool_val = FALSE;
1245       }
1246     } else {
1247       config_process_error_f("No macro or environmental variable defined"
1248         " with name `%s'", macroname);
1249       yylval.bool_val = FALSE;
1250     }
1251     Free(macroname);
1252   } else {
1253     config_process_error("Internal error: Macro reference cannot be used in "
1254       "this context.");
1255     yylval.bool_val = FALSE;
1256   }
1257   return BooleanValue;
1258 }
1259
1260 {MACRO_INT} {
1261   if (config_defines != NULL) {
1262     char *macroname = get_macro_id_from_ref(yytext);
1263     size_t macrolen;
1264     const char *macrovalue =
1265       string_map_get_bykey(config_defines, macroname, &macrolen);
1266     if (macrovalue != NULL) {
1267       if (string_is_int(macrovalue, macrolen))
1268         yylval.int_val = new int_val_t(macrovalue);
1269       else {
1270         config_process_error_f("Macro `%s' cannot be interpreted as integer "
1271           "value: `%s'", macroname, macrovalue);
1272         yylval.int_val = new int_val_t((RInt)0);
1273       }
1274     } else {
1275       config_process_error_f("No macro or environmental variable defined"
1276         " with name `%s'", macroname);
1277       yylval.int_val = new int_val_t((RInt)0);
1278     }
1279     Free(macroname);
1280   } else {
1281     config_process_error("Internal error: Macro reference cannot be used in "
1282       "this context.");
1283     yylval.int_val = new int_val_t((RInt)0);
1284   }
1285   if (YY_START == SC_MODULE_PARAMETERS) {
1286     // return a different token for module parameters so it doesn't conflict with references
1287     return MPNumber;
1288   }
1289   return Number;
1290 }
1291
1292 {MACRO_FLOAT} {
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     if (macrovalue != NULL) {
1299       if (string_is_float(macrovalue, macrolen))
1300         yylval.float_val = atof(macrovalue);
1301       else {
1302         config_process_error_f("Macro `%s' cannot be interpreted as float value: "
1303           "`%s'", macroname, macrovalue);
1304         yylval.float_val = 0.0;
1305       }
1306     } else {
1307       config_process_error_f("No macro or environmental variable defined"
1308         " with name `%s'", macroname);
1309       yylval.float_val = 0.0;
1310     }
1311     Free(macroname);
1312   } else {
1313     config_process_error("Internal error: Macro reference cannot be used in "
1314       "this context.");
1315     yylval.float_val = 0.0;
1316   }
1317   if (YY_START == SC_MODULE_PARAMETERS) {
1318     // return a different token for module parameters so it doesn't conflict with references
1319     return MPFloat;
1320   }
1321   return Float;
1322 }
1323
1324 {MACRO_ID} {
1325   if (config_defines != NULL) {
1326     char *macroname = get_macro_id_from_ref(yytext);
1327     size_t macrolen;
1328     const char *macrovalue =
1329       string_map_get_bykey(config_defines, macroname, &macrolen);
1330     boolean is_asn = FALSE;
1331     if (macrovalue != NULL) {
1332       if (string_is_id(macrovalue, macrolen)) {
1333         yylval.str_val = mcopystr(macrovalue);
1334         for (size_t i = 0; i < macrolen; i++) {
1335           if (yylval.str_val[i]=='-') {
1336             yylval.str_val[i] = '_';
1337             is_asn = TRUE;
1338           }
1339         }
1340         if (is_asn)
1341           TTCN_warning("In line %d of configuration file: `%s' is not a valid"
1342                        " TTCN-3 identifier. Did you mean `%s'?",
1343                        current_line, macrovalue, yylval.str_val);
1344       } else {
1345         config_process_error_f("Macro `%s' cannot be interpreted as identifier: "
1346           "`%s'", macroname, macrovalue);
1347         yylval.str_val = memptystr();
1348       }
1349     } else {
1350       config_process_error_f("No macro or environmental variable defined with "
1351         "name `%s'", macroname);
1352       yylval.str_val = memptystr();
1353     }
1354     Free(macroname);
1355     return is_asn ? ASN1LowerIdentifier : Identifier;
1356   } else {
1357     config_process_error("Internal error: Macro reference cannot be used in "
1358       "this context.");
1359     yylval.str_val = memptystr();
1360     return Identifier;
1361   }
1362 }
1363
1364 {MACRO_CSTR} {
1365   if (config_defines == NULL) {
1366     config_process_error("Internal error: Macro reference cannot be used in "
1367         "this context.");
1368     yylval.charstring_val.n_chars = 0;
1369     yylval.charstring_val.chars_ptr = memptystr();
1370     if (YY_START == SC_MODULE_PARAMETERS) {
1371       // return a different token for module parameters so it doesn't conflict with references
1372       return MPCstring;
1373     }
1374     return Cstring;
1375   }
1376
1377   char *macroname;
1378   if (yytext[1] == '{') macroname = get_macro_id_from_ref(yytext);
1379   else macroname = mcopystr(yytext + 1);
1380   size_t macrolen;
1381   const char *macrovalue = string_map_get_bykey
1382     (config_defines, macroname, &macrolen);
1383
1384   if (macrovalue == NULL) {
1385     config_process_error_f("No macro or environmental variable defined with name "
1386         "`%s'", macroname);
1387     yylval.charstring_val.n_chars=0;
1388     yylval.charstring_val.chars_ptr=memptystr();
1389     Free(macroname);
1390     if (YY_START == SC_MODULE_PARAMETERS) {
1391       // return a different token for module parameters so it doesn't conflict with references
1392       return MPCstring;
1393     }
1394     return Cstring;
1395   }
1396
1397   if (macrolen > 0 && macrovalue[0] == '{') { // structured
1398     main_buffer = YY_CURRENT_BUFFER;
1399     expansion_buffer = yy_scan_string(macrovalue);
1400     yy_switch_to_buffer(expansion_buffer);
1401     Free(macroname);
1402   } else {
1403     yylval.charstring_val.n_chars=macrolen;
1404     yylval.charstring_val.chars_ptr=(char*)Malloc(macrolen+1);
1405     memcpy(yylval.charstring_val.chars_ptr, macrovalue, macrolen+1);
1406     Free(macroname);
1407     if (YY_START == SC_MODULE_PARAMETERS) {
1408       // return a different token for module parameters so it doesn't conflict with references
1409       return MPCstring;
1410     }
1411     return Cstring;
1412   }
1413 }
1414
1415 {MACRO_BSTR} {
1416   if (config_defines != NULL) {
1417     char *macroname = get_macro_id_from_ref(yytext);
1418     size_t macrolen;
1419     const char *macrovalue =
1420       string_map_get_bykey(config_defines, macroname, &macrolen);
1421     if (macrovalue != NULL) {
1422       if (string_is_bstr(macrovalue, macrolen)) {
1423         yylval.bitstring_val.n_bits = macrolen;
1424         int n_bytes = (yylval.bitstring_val.n_bits + 7) / 8;
1425         yylval.bitstring_val.bits_ptr = (unsigned char *)Malloc(n_bytes);
1426         memset(yylval.bitstring_val.bits_ptr, 0, n_bytes);
1427         for (int i = 0; i < yylval.bitstring_val.n_bits; i++)
1428           if (macrovalue[i] == '1')
1429             yylval.bitstring_val.bits_ptr[i/8] |= 1 << (i % 8);
1430       } else {
1431         config_process_error_f("Macro `%s' cannot be interpreted as bitstring "
1432           "value: `%s'", macroname, macrovalue);
1433         yylval.bitstring_val.n_bits = 0;
1434         yylval.bitstring_val.bits_ptr = NULL;
1435       }
1436     } else {
1437       config_process_error_f("No macro or environmental variable defined with "
1438         "name `%s'", macroname);
1439       yylval.bitstring_val.n_bits = 0;
1440       yylval.bitstring_val.bits_ptr = NULL;
1441     }
1442     Free(macroname);
1443   } else {
1444     config_process_error_f("Internal error: Macro reference cannot be used in "
1445       "this context.");
1446     yylval.bitstring_val.n_bits = 0;
1447     yylval.bitstring_val.bits_ptr = NULL;
1448   }
1449   return Bstring;
1450 }
1451
1452 {MACRO_HSTR} {
1453   if (config_defines != NULL) {
1454     char *macroname = get_macro_id_from_ref(yytext);
1455     size_t macrolen;
1456     const char *macrovalue =
1457       string_map_get_bykey(config_defines, macroname, &macrolen);
1458     if (macrovalue != NULL) {
1459       if(string_is_hstr(macrovalue, macrolen)) {
1460         yylval.hexstring_val.n_nibbles = macrolen;
1461         int n_bytes = (yylval.hexstring_val.n_nibbles + 1) / 2;
1462         yylval.hexstring_val.nibbles_ptr = (unsigned char *)Malloc(n_bytes);
1463         memset(yylval.hexstring_val.nibbles_ptr, 0, n_bytes);
1464         for (int i = 0; i < yylval.hexstring_val.n_nibbles; i++) {
1465           unsigned int hex_digit;
1466           sscanf(macrovalue+i, "%1x", &hex_digit);
1467           if(i % 2) yylval.hexstring_val.nibbles_ptr[i/2] |=
1468             (hex_digit << 4);
1469           else yylval.hexstring_val.nibbles_ptr[i/2] |= hex_digit;
1470         }
1471       } else {
1472         config_process_error_f("Macro `%s' cannot be interpreted as hexstring "
1473           "value: `%s'", macroname, macrovalue);
1474         yylval.hexstring_val.n_nibbles = 0;
1475         yylval.hexstring_val.nibbles_ptr = NULL;
1476       }
1477     } else {
1478       config_process_error_f("No macro or environmental variable defined with "
1479         "name `%s'", macroname);
1480       yylval.hexstring_val.n_nibbles = 0;
1481       yylval.hexstring_val.nibbles_ptr = NULL;
1482     }
1483     Free(macroname);
1484   } else {
1485     config_process_error("Internal error: Macro reference cannot be used in "
1486       "this context.");
1487     yylval.hexstring_val.n_nibbles = 0;
1488     yylval.hexstring_val.nibbles_ptr = NULL;
1489   }
1490   return Hstring;
1491 }
1492
1493 {MACRO_OSTR} {
1494   if (config_defines != NULL) {
1495     char *macroname = get_macro_id_from_ref(yytext);
1496     size_t macrolen;
1497     const char *macrovalue =
1498       string_map_get_bykey(config_defines, macroname, &macrolen);
1499     if (macrovalue != NULL) {
1500       if (string_is_ostr(macrovalue, macrolen)) {
1501         yylval.octetstring_val.n_octets = macrolen / 2;
1502         yylval.octetstring_val.octets_ptr = (unsigned char *)
1503           Malloc(yylval.octetstring_val.n_octets);
1504         for (int i = 0; i < yylval.octetstring_val.n_octets; i++) {
1505           unsigned int this_octet;
1506           sscanf(macrovalue+2*i, "%2x", &this_octet);
1507           yylval.octetstring_val.octets_ptr[i] = this_octet;
1508         }
1509       } else {
1510         config_process_error_f("Macro `%s' cannot be interpreted as octetstring "
1511           "value: `%s'", macroname, macrovalue);
1512         yylval.octetstring_val.n_octets = 0;
1513         yylval.octetstring_val.octets_ptr = NULL;
1514       }
1515     } else {
1516       config_process_error_f("No macro or environmental variable defined with "
1517         "name `%s'", macroname);
1518       yylval.octetstring_val.n_octets = 0;
1519       yylval.octetstring_val.octets_ptr = NULL;
1520     }
1521     Free(macroname);
1522   } else {
1523     config_process_error_f("Internal error: Macro reference cannot be used in "
1524       "this context.");
1525     yylval.octetstring_val.n_octets = 0;
1526     yylval.octetstring_val.octets_ptr = NULL;
1527   }
1528   return Ostring;
1529 }
1530
1531 {MACRO_BINARY} {
1532   if (config_defines != NULL) {
1533     char *macroname = get_macro_id_from_ref(yytext);
1534     size_t macrolen;
1535     const char *macrovalue =
1536       string_map_get_bykey(config_defines, macroname, &macrolen);
1537     if (macrovalue != NULL) {
1538       yylval.octetstring_val.n_octets=macrolen;
1539       yylval.octetstring_val.octets_ptr = (unsigned char*)Malloc(macrolen);
1540       memcpy(yylval.octetstring_val.octets_ptr, macrovalue, macrolen);
1541     }
1542     else {
1543       config_process_error_f("No macro or environmental variable defined with "
1544         "name `%s'", macroname);
1545       yylval.octetstring_val.n_octets = 0;
1546       yylval.octetstring_val.octets_ptr = NULL;
1547     }
1548     Free(macroname);
1549   } else {
1550     config_process_error("Internal error: Macro reference cannot be used in "
1551       "this context.");
1552     yylval.octetstring_val.n_octets = 0;
1553     yylval.octetstring_val.octets_ptr = NULL;
1554   }
1555   return Ostring;
1556 }
1557
1558 {MACRO_HOSTNAME} {
1559   if (config_defines != NULL) {
1560     char *macroname = get_macro_id_from_ref(yytext);
1561     size_t macrolen;
1562     const char *macrovalue =
1563       string_map_get_bykey(config_defines, macroname, &macrolen);
1564     if (macrovalue != NULL) {
1565       if (!string_is_hostname(macrovalue, macrolen)) {
1566         config_process_error_f("Macro `%s' cannot be interpreted as host name: "
1567           "`%s'", macroname, macrovalue);
1568       }
1569     } else {
1570       config_process_error_f("No macro or environmental variable defined with "
1571         "name `%s'", macroname);
1572     }
1573     Free(macroname);
1574   } else {
1575     config_process_error("Internal error: Macro reference cannot be used in "
1576       "this context.");
1577   }
1578   return DNSName;
1579 }
1580
1581 ":="|"="    return AssignmentChar;
1582 "&="        return ConcatChar;
1583
1584 <<EOF>> {
1585    if (expansion_buffer) {
1586      yy_switch_to_buffer(main_buffer);
1587      yy_delete_buffer(expansion_buffer);
1588      expansion_buffer = NULL;
1589    } else {
1590      if (include_chain->size() > 1) {
1591        yy_delete_buffer(YY_CURRENT_BUFFER);
1592        fclose(include_chain->back().fp);
1593        include_chain->pop_back();
1594        yy_switch_to_buffer(include_chain->back().buffer_state);
1595        current_line = include_chain->back().line_number;
1596        BEGIN(SC_ORDERED_INCLUDE);
1597      } else {
1598        yyterminate();
1599        return EOF;
1600      }
1601    }
1602  }
1603
1604
1605
1606 .           return yytext[0];
1607
1608
1609 %%
1610
1611 void reset_config_process_lex(const char* fname)
1612 {
1613   if (!include_chain) {
1614     include_chain = new std::deque<IncludeElem<YY_BUFFER_STATE> >();
1615   }
1616   BEGIN(INITIAL);
1617   current_line = 1;
1618   if (fname) {
1619     include_chain->push_back(IncludeElem<YY_BUFFER_STATE>(std::string(fname), config_process_in));
1620   }
1621 }
1622
1623 void config_process_close() {
1624   delete include_chain;
1625   include_chain = NULL;
1626 }
1627
1628 int config_process_get_current_line()
1629 {
1630   return current_line;
1631 }
1632
1633