core/config_process.l

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