1 /******************************************************************************
2 * Copyright (c) 2000-2016 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
19 * Szabo, Janos Zoltan – initial implementation
21 * Zalanyi, Balazs Andor
23 ******************************************************************************/
25 %option never-interactive
37 #include "../common/cfg_process_utils.hh"
38 #include "../common/Path2.hh"
40 #include "../common/memory.h"
42 #include "Parameters.h"
43 #include "Param_Types.hh"
45 #include "LoggingBits.hh"
46 #include "LoggingParam.hh"
48 #include "config_process.tab.hh"
49 #include "../common/config_preproc.h"
50 #include "../common/path.h"
52 #include "../common/dbgnew.hh"
54 #include "Profiler.hh"
56 extern string_map_t *config_defines;
58 #define yylval config_process_lval
60 static int current_line;
62 static YY_BUFFER_STATE main_buffer = NULL;
63 /* This buffer is used for macro expansion */
64 static YY_BUFFER_STATE expansion_buffer = NULL;
66 static std::deque<IncludeElem<YY_BUFFER_STATE> >* include_chain = NULL;
68 static void set_ret_val_cstr(const std::string& cstring) {
69 param_charstring_t& ch_val = yylval.charstring_val;
70 ch_val.n_chars = cstring.size();
71 ch_val.chars_ptr = (char*) Malloc(ch_val.n_chars + 1);
72 memcpy(ch_val.chars_ptr, cstring.c_str(), cstring.size() + 1);
75 std::string get_cfg_process_current_file() {
76 if (include_chain && !include_chain->empty()) {
77 return include_chain->back().get_full_path();
88 LINECOMMENT ("//"|"#")[^\r\n]*{NEWLINE}
90 NUMBER 0|([1-9][0-9]*)
92 FLOAT [+-]?({NUMBER}\.[0-9]+)|((({NUMBER}(\.[0-9]+)?)|(\.[0-9]+))[Ee][+-]?{NUMBER})
97 BITSTRINGMATCH '{BINMATCH}*'B
98 BITSTRING_BAD '[^']*'B
102 HEXMATCH [0-9A-Fa-f\?\*]
103 HEXSTRINGMATCH '{HEXMATCH}*'H
104 HEXSTRING_BAD '[^']*'H
107 OCTETSTRING '{OCT}*'O
108 OCTMATCH {HEX}{HEX}|\?|\*
109 OCTETSTRINGMATCH '{OCTMATCH}*'O
110 OCTETSTRING_BAD '[^']*'O
112 BINSTRING_BAD '[^']*'
114 TTCN3IDENTIFIER [A-Za-z][A-Za-z0-9_]*
115 ASN1LOWERIDENTIFIER [a-z](-?[A-Za-z0-9]+)*
117 COMPONENT .*\({NUMBER}\)
119 MACRO_CSTR \${TTCN3IDENTIFIER}|\$"{"{WS}{TTCN3IDENTIFIER}{WS}(","{WS}charstring{WS})?"}"
120 MACRO_BOOL \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}boolean{WS}"}"
121 MACRO_FLOAT \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}float{WS}"}"
122 MACRO_ID \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}identifier{WS}"}"
123 MACRO_INT \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}integer{WS}"}"
124 MACRO_BSTR \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}bitstring{WS}"}"
125 MACRO_HSTR \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}hexstring{WS}"}"
126 MACRO_OSTR \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}octetstring{WS}"}"
127 MACRO_BINARY \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}binaryoctet{WS}"}"
128 MACRO_HOSTNAME \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}hostname{WS}"}"
130 HOSTNAME [A-Za-z0-9]([A-Za-z0-9_\-]*[A-Za-z0-9])?
131 DNSNAME {HOSTNAME}(\.{HOSTNAME})*\.?
133 /* Example: fe80::c002:37ff:fe6c:0%fastethernet0/0 */
134 IPV6 [0-9A-Fa-f:.]+(%[0-9A-Za-z]+)?
136 TTCNSTRINGPARSING "$#&&&(#TTCNSTRINGPARSING$#&&^#% "
137 TTCNSTRINGPARSING_COMPONENT "$#&&&(#TTCNSTRINGPARSING_COMPONENT$#&&^#% "
139 %x SC_commentblock SC_cstring SC_DEFINE
140 %s SC_MODULE_PARAMETERS SC_LOGGING SC_TESTPORT_PARAMETERS SC_EXECUTE SC_GROUPS
141 %s SC_COMPONENTS SC_EXTERNAL_COMMANDS SC_MAIN_CONTROLLER SC_INCLUDE SC_ORDERED_INCLUDE
142 %s SC_STRING2TTCN_COMPONENT SC_PROFILER
146 int caller_state = INITIAL;
148 int cstring_start = -1;
150 /* Eat up comments and whitespaces */
153 caller_state = YY_START;
154 BEGIN(SC_commentblock);
158 "*/" BEGIN(caller_state);
159 {NEWLINE} current_line++;
162 config_process_error("Unterminated block comment (missing */ at the "
170 {LINECOMMENT} current_line++;
172 {TTCNSTRINGPARSING} {
173 if (Ttcn_String_Parsing::happening()) {
174 BEGIN(SC_MODULE_PARAMETERS);
175 return TtcnStringParsingKeyword;
177 config_process_error("Invalid character sequence encountered.");
181 {TTCNSTRINGPARSING_COMPONENT} {
182 if (Ttcn_String_Parsing::happening()) {
183 BEGIN(SC_STRING2TTCN_COMPONENT);
184 return TtcnStringParsingKeyword;
186 config_process_error("Invalid character sequence encountered.");
190 /* Section delimiters */
192 <*>"["{WS}MODULE_PARAMETERS{WS}"]" {
193 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
194 BEGIN(SC_MODULE_PARAMETERS);
195 return ModuleParametersKeyword;
199 <*>"["{WS}LOGGING{WS}"]" {
200 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
202 return LoggingKeyword;
206 <*>"["{WS}PROFILER{WS}"]" {
207 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
209 return ProfilerKeyword;
213 <*>"["{WS}TESTPORT_PARAMETERS{WS}"]" {
214 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
215 BEGIN(SC_TESTPORT_PARAMETERS);
216 return TestportParametersKeyword;
220 <*>"["{WS}EXECUTE{WS}"]" {
221 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
223 return ExecuteKeyword;
227 <*>"["{WS}EXTERNAL_COMMANDS{WS}"]" {
228 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
229 BEGIN(SC_EXTERNAL_COMMANDS);
230 return ExternalCommandsKeyword;
234 <*>"["{WS}GROUPS{WS}"]" {
235 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
237 return GroupsKeyword;
241 <*>"["{WS}COMPONENTS{WS}"]" {
242 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
243 BEGIN(SC_COMPONENTS);
244 return ComponentsKeyword;
248 <*>"["{WS}MAIN_CONTROLLER{WS}"]" {
249 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
250 BEGIN(SC_MAIN_CONTROLLER);
251 return MainControllerKeyword;
255 <*>"["{WS}INCLUDE{WS}"]" {
256 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
258 return IncludeKeyword;
262 <*>"["{WS}ORDERED_INCLUDE{WS}"]" {
263 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
264 BEGIN(SC_ORDERED_INCLUDE);
268 <*>"["{WS}DEFINE{WS}"]" {
269 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
271 return DefineKeyword;
275 /* Rules for SC_DEFINE must precede everything else */
280 caller_state = SC_DEFINE;
281 BEGIN(SC_commentblock);
285 caller_state = SC_DEFINE;
288 cstring_start = current_line;
291 {LINECOMMENT}|{NEWLINE} current_line++;
295 . /* eat unnecessary chars */
299 <SC_PROFILER>{HEX}+ {
300 /* numeric statistics filter (check this before checking for NUMBERs) */
302 while(0 != *yytext) {
303 yylval.uint_val *= 16;
304 if ('0' <= *yytext && '9' >= *yytext) {
305 yylval.uint_val += *yytext - '0';
307 else if ('a' <= *yytext && 'f' >= *yytext) {
308 yylval.uint_val += *yytext - 'a' + 10;
311 yylval.uint_val += *yytext - 'A' + 10;
315 return ProfilerStatsFlag;
321 yylval.int_val = new int_val_t(yytext);
322 if (YY_START == SC_MODULE_PARAMETERS) {
323 // return a different token for module parameters so it doesn't conflict with references
330 yylval.float_val = atof(yytext);
331 if (YY_START == SC_MODULE_PARAMETERS) {
332 // return a different token for module parameters so it doesn't conflict with references
339 yylval.bitstring_val.n_bits = yyleng - 3;
340 int n_bytes = (yylval.bitstring_val.n_bits + 7) / 8;
341 yylval.bitstring_val.bits_ptr = (unsigned char *)Malloc(n_bytes);
342 memset(yylval.bitstring_val.bits_ptr, 0, n_bytes);
343 for (int i = 0; i < yylval.bitstring_val.n_bits; i++)
344 if (yytext[i+1] == '1')
345 yylval.bitstring_val.bits_ptr[i/8] |= 1 << (i % 8);
350 yylval.str_val = mcopystrn(yytext+1, yyleng-3);
355 config_process_error("Invalid bitstring value.");
356 yylval.bitstring_val.n_bits = 0;
357 yylval.bitstring_val.bits_ptr = NULL;
362 yylval.hexstring_val.n_nibbles = yyleng - 3;
363 int n_bytes = (yylval.hexstring_val.n_nibbles + 1) / 2;
364 yylval.hexstring_val.nibbles_ptr = (unsigned char *)Malloc(n_bytes);
365 memset(yylval.hexstring_val.nibbles_ptr, 0, n_bytes);
366 for (int i = 0; i < yylval.hexstring_val.n_nibbles; i++) {
367 unsigned int hex_digit;
368 sscanf(yytext+i+1, "%1x", &hex_digit);
369 if(i % 2) yylval.hexstring_val.nibbles_ptr[i/2] |=
371 else yylval.hexstring_val.nibbles_ptr[i/2] |= hex_digit;
377 yylval.str_val = mcopystrn(yytext+1, yyleng-3);
382 config_process_error("Invalid hexstring value.");
383 yylval.hexstring_val.n_nibbles = 0;
384 yylval.hexstring_val.nibbles_ptr = NULL;
389 yylval.octetstring_val.n_octets = (yyleng - 3) / 2;
390 yylval.octetstring_val.octets_ptr = (unsigned char *)
391 Malloc(yylval.octetstring_val.n_octets);
393 for (int i = 0; i < yylval.octetstring_val.n_octets; i++) {
394 unsigned int this_octet;
395 sscanf(yytext+2*i+1, "%2x", &this_octet);
396 yylval.octetstring_val.octets_ptr[i] = this_octet;
402 yylval.str_val = mcopystrn(yytext+1, yyleng-3);
407 config_process_error("Invalid octetstring value.");
408 yylval.octetstring_val.n_octets = 0;
409 yylval.octetstring_val.octets_ptr = NULL;
413 {BINSTRING_BAD} config_process_error("Invalid string value.");
415 ' config_process_error("Unmatched ' character.");
418 caller_state = YY_START;
421 cstring_start = current_line;
428 /* end of the string */
430 switch (caller_state) {
434 case SC_ORDERED_INCLUDE:
436 std::string error_msg = switch_lexer(include_chain, cstring,
437 YY_CURRENT_BUFFER, yy_create_buffer, yy_switch_to_buffer,
438 current_line, YY_BUF_SIZE);
439 if (error_msg.empty()) {
442 config_process_error(error_msg.c_str());
447 set_ret_val_cstr(cstring);
448 if (caller_state == SC_MODULE_PARAMETERS) {
449 // return a different token for module parameters so it doesn't conflict with references
458 \\[\\'"?] cstring += yytext[1]; /* backslash-quoted \ or " or ' or ? */
459 \\{NEWLINE} current_line++;
469 sscanf(yytext + 1, "%o", &c);
471 config_process_error("Invalid octal character code in string "
473 else if (c == 0 && caller_state != SC_MODULE_PARAMETERS)
474 config_process_error("NUL characters in string literals are "
475 "allowed only in section [MODULE_PARAMETERS].");
480 sscanf(yytext + 2, "%x", &c);
481 if (c == 0 && caller_state != SC_MODULE_PARAMETERS)
482 config_process_error("NUL characters in string literals are "
483 "allowed only in section [MODULE_PARAMETERS].");
487 config_process_error("Invalid escape sequence in string literal.");
490 cstring.append(yytext, yyleng);
493 . cstring += yytext[0];
495 if (cstring_start >=0) {
496 config_process_error_f("Unterminated string literal starting at line %d "
497 "(missing \" at the end of file).", cstring_start);
499 config_process_error("Unterminated string literal (missing \" at the "
503 if (caller_state!=SC_DEFINE) {
504 set_ret_val_cstr(cstring);
505 if (caller_state == SC_MODULE_PARAMETERS) {
506 // return a different token for module parameters so it doesn't conflict with references
516 /* Section-wide keywords */
518 <SC_MODULE_PARAMETERS>
520 NULL return NULLKeyword;
521 null return nullKeyword;
522 char return CharKeyword;
523 objid return ObjIdKeyword;
524 omit return OmitKeyword;
526 yylval.verdict_val = NONE;
530 yylval.verdict_val = PASS;
534 yylval.verdict_val = INCONC;
538 yylval.verdict_val = FAIL;
542 yylval.verdict_val = ERROR;
545 complement return ComplementKeyword;
546 "\.\." return DotDot;
547 superset return SupersetKeyword;
548 subset return SubsetKeyword;
549 pattern return PatternKeyword;
550 permutation return PermutationKeyword;
551 length return LengthKeyword;
552 ifpresent return IfpresentKeyword;
553 infinity return InfinityKeyword;
556 <SC_MODULE_PARAMETERS,SC_LOGGING,SC_PROFILER>
559 yylval.bool_val = TRUE;
563 yylval.bool_val = FALSE;
568 /* We could add SC_LOGGING to make mtc and system special for the logging section too */
569 <SC_MODULE_PARAMETERS,SC_STRING2TTCN_COMPONENT,SC_TESTPORT_PARAMETERS,SC_LOGGING>
571 mtc return MTCKeyword;
572 system return SystemKeyword;
578 [Ll]og[Ff]ile return LogFile;
580 [Ee]mergency[Ll]ogging return EmergencyLogging;
582 [Ee]mergency[Ll]ogging[Bb]ehaviour return EmergencyLoggingBehaviour;
584 [Ee]mergency[Ll]ogging[Mm]ask return EmergencyLoggingMask;
586 [Ee]mergency[Ll]ogging[Ff]or[Ff]ail[Vv]erdict return EmergencyLoggingForFailVerdict;
588 [Ff]ile[Mm]ask return FileMask;
590 [Cc]onsole[Mm]ask return ConsoleMask;
592 [Tt]ime[Ss]tamp[Ff]ormat return TimestampFormat;
593 [Cc]onsole[Tt]ime[Ss]tamp[Ff]ormat return ConsoleTimestampFormat;
595 [Ll]og[Ss]ource[Ii]nfo |
596 [Ss]ource[Ii]nfo[Ff]ormat return SourceInfoFormat;
598 [Aa]ppend[Ff]ile return AppendFile;
600 [Ll]og[Ee]vent[Tt]ypes return LogEventTypes;
602 [Ll]og[Ee]ntity[Nn]ame return LogEntityName;
604 [Ll]og[Ff]ile[Ss]ize return LogFileSize;
606 [Ll]og[Ff]ile[Nn]umber return LogFileNumber;
608 [Dd]isk[Ff]ull[Aa]ction return DiskFullAction;
610 [Mm]atching[Hh]ints return MatchingHints;
612 [Ll]ogger[Pp]lugins return LoggerPlugins;
614 /* Lexer's handling of logging keywords:
616 * For sub-categories and categories with only one member,
617 * LoggingBit is returned and the value is the corresponding
618 * TTCN_Logger::Severity.
620 * For the old categories which now have subcategories, the old keyword
621 * is returned as LoggingBitCollection with the corresponding
622 * _UNQUALIFIED as the semantic value. The parser will construct the
625 * The lexer never returns a token with a Logging_Bits type.
628 yylval.logseverity_val = TTCN_Logger::NOTHING_TO_LOG;
633 yylval.logseverity_val = TTCN_Logger::ACTION_UNQUALIFIED;
637 yylval.logseverity_val = TTCN_Logger::ACTION_UNQUALIFIED;
638 return LoggingBitCollection;
642 yylval.logseverity_val = TTCN_Logger::DEBUG_ENCDEC;
646 yylval.logseverity_val = TTCN_Logger::DEBUG_TESTPORT;
650 yylval.logseverity_val = TTCN_Logger::DEBUG_USER;
654 yylval.logseverity_val = TTCN_Logger::DEBUG_FRAMEWORK;
658 yylval.logseverity_val = TTCN_Logger::DEBUG_UNQUALIFIED;
662 yylval.logseverity_val = TTCN_Logger::DEBUG_UNQUALIFIED;
663 return LoggingBitCollection;
667 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_ACTIVATE;
670 DEFAULTOP_DEACTIVATE {
671 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_DEACTIVATE;
675 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_EXIT;
678 DEFAULTOP_UNQUALIFIED {
679 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_UNQUALIFIED;
683 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_UNQUALIFIED;
684 return LoggingBitCollection;
688 yylval.logseverity_val = TTCN_Logger::ERROR_UNQUALIFIED;
692 yylval.logseverity_val = TTCN_Logger::ERROR_UNQUALIFIED;
693 return LoggingBitCollection;
697 yylval.logseverity_val = TTCN_Logger::EXECUTOR_COMPONENT;
700 EXECUTOR_CONFIGDATA {
701 yylval.logseverity_val = TTCN_Logger::EXECUTOR_CONFIGDATA;
704 EXECUTOR_EXTCOMMAND {
705 yylval.logseverity_val = TTCN_Logger::EXECUTOR_EXTCOMMAND;
708 EXECUTOR_LOGOPTIONS {
709 yylval.logseverity_val = TTCN_Logger::EXECUTOR_LOGOPTIONS;
713 yylval.logseverity_val = TTCN_Logger::EXECUTOR_RUNTIME;
716 EXECUTOR_UNQUALIFIED {
717 yylval.logseverity_val = TTCN_Logger::EXECUTOR_UNQUALIFIED;
721 yylval.logseverity_val = TTCN_Logger::EXECUTOR_UNQUALIFIED;
722 return LoggingBitCollection;
726 yylval.logseverity_val = TTCN_Logger::FUNCTION_RND;
729 FUNCTION_UNQUALIFIED {
730 yylval.logseverity_val = TTCN_Logger::FUNCTION_UNQUALIFIED;
734 yylval.logseverity_val = TTCN_Logger::FUNCTION_UNQUALIFIED;
735 return LoggingBitCollection;
739 yylval.logseverity_val = TTCN_Logger::MATCHING_DONE;
743 yylval.logseverity_val = TTCN_Logger::MATCHING_MCSUCCESS;
747 yylval.logseverity_val = TTCN_Logger::MATCHING_MCUNSUCC;
751 yylval.logseverity_val = TTCN_Logger::MATCHING_MMSUCCESS;
755 yylval.logseverity_val = TTCN_Logger::MATCHING_MMUNSUCC;
759 yylval.logseverity_val = TTCN_Logger::MATCHING_PCSUCCESS;
763 yylval.logseverity_val = TTCN_Logger::MATCHING_PCUNSUCC;
767 yylval.logseverity_val = TTCN_Logger::MATCHING_PMSUCCESS;
771 yylval.logseverity_val = TTCN_Logger::MATCHING_PMUNSUCC;
775 yylval.logseverity_val = TTCN_Logger::MATCHING_PROBLEM;
779 yylval.logseverity_val = TTCN_Logger::MATCHING_TIMEOUT;
782 MATCHING_UNQUALIFIED {
783 yylval.logseverity_val = TTCN_Logger::MATCHING_UNQUALIFIED;
787 yylval.logseverity_val = TTCN_Logger::MATCHING_UNQUALIFIED;
788 return LoggingBitCollection;
792 yylval.logseverity_val = TTCN_Logger::PARALLEL_PORTCONN;
796 yylval.logseverity_val = TTCN_Logger::PARALLEL_PORTMAP;
800 yylval.logseverity_val = TTCN_Logger::PARALLEL_PTC;
803 PARALLEL_UNQUALIFIED {
804 yylval.logseverity_val = TTCN_Logger::PARALLEL_UNQUALIFIED;
808 yylval.logseverity_val = TTCN_Logger::PARALLEL_UNQUALIFIED;
809 return LoggingBitCollection;
813 yylval.logseverity_val = TTCN_Logger::PORTEVENT_DUALRECV;
817 yylval.logseverity_val = TTCN_Logger::PORTEVENT_DUALSEND;
821 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MCRECV;
825 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MCSEND;
829 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MMRECV;
833 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MMSEND;
837 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MQUEUE;
841 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PCIN;
845 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PCOUT;
849 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PMIN;
853 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PMOUT;
857 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PQUEUE;
861 yylval.logseverity_val = TTCN_Logger::PORTEVENT_STATE;
864 PORTEVENT_UNQUALIFIED {
865 yylval.logseverity_val = TTCN_Logger::PORTEVENT_UNQUALIFIED;
869 yylval.logseverity_val = TTCN_Logger::PORTEVENT_UNQUALIFIED;
870 return LoggingBitCollection;
873 STATISTICS_UNQUALIFIED {
874 yylval.logseverity_val = TTCN_Logger::STATISTICS_UNQUALIFIED;
878 yylval.logseverity_val = TTCN_Logger::STATISTICS_VERDICT;
882 yylval.logseverity_val = TTCN_Logger::STATISTICS_UNQUALIFIED;
883 return LoggingBitCollection;
887 yylval.logseverity_val = TTCN_Logger::TESTCASE_FINISH;
891 yylval.logseverity_val = TTCN_Logger::TESTCASE_START;
894 TESTCASE_UNQUALIFIED {
895 yylval.logseverity_val = TTCN_Logger::TESTCASE_UNQUALIFIED;
899 yylval.logseverity_val = TTCN_Logger::TESTCASE_UNQUALIFIED;
900 return LoggingBitCollection;
904 yylval.logseverity_val = TTCN_Logger::TIMEROP_GUARD;
908 yylval.logseverity_val = TTCN_Logger::TIMEROP_READ;
912 yylval.logseverity_val = TTCN_Logger::TIMEROP_START;
916 yylval.logseverity_val = TTCN_Logger::TIMEROP_STOP;
920 yylval.logseverity_val = TTCN_Logger::TIMEROP_TIMEOUT;
923 TIMEROP_UNQUALIFIED {
924 yylval.logseverity_val = TTCN_Logger::TIMEROP_UNQUALIFIED;
928 yylval.logseverity_val = TTCN_Logger::TIMEROP_UNQUALIFIED;
929 return LoggingBitCollection;
933 yylval.logseverity_val = TTCN_Logger::USER_UNQUALIFIED;
937 yylval.logseverity_val = TTCN_Logger::USER_UNQUALIFIED;
938 return LoggingBitCollection;
942 yylval.logseverity_val = TTCN_Logger::VERDICTOP_FINAL;
945 VERDICTOP_GETVERDICT {
946 yylval.logseverity_val = TTCN_Logger::VERDICTOP_GETVERDICT;
949 VERDICTOP_SETVERDICT {
950 yylval.logseverity_val = TTCN_Logger::VERDICTOP_SETVERDICT;
953 VERDICTOP_UNQUALIFIED {
954 yylval.logseverity_val = TTCN_Logger::VERDICTOP_UNQUALIFIED;
958 yylval.logseverity_val = TTCN_Logger::VERDICTOP_UNQUALIFIED;
959 return LoggingBitCollection;
962 WARNING_UNQUALIFIED {
963 yylval.logseverity_val = TTCN_Logger::WARNING_UNQUALIFIED;
967 yylval.logseverity_val = TTCN_Logger::WARNING_UNQUALIFIED;
968 return LoggingBitCollection;
972 yylval.logseverity_val = TTCN_Logger::LOG_ALL_IMPORTANT;
973 return LoggingBitCollection;
977 yylval.timestamp_value = TTCN_Logger::TIMESTAMP_TIME;
978 return TimestampValue;
980 [Dd][Aa][Tt][Ee][Tt][Ii][Mm][Ee] {
981 yylval.timestamp_value = TTCN_Logger::TIMESTAMP_DATETIME;
982 return TimestampValue;
984 [Ss][Ee][Cc][Oo][Nn][Dd][Ss] {
985 yylval.timestamp_value = TTCN_Logger::TIMESTAMP_SECONDS;
986 return TimestampValue;
989 yylval.source_info_value = TTCN_Logger::SINFO_NONE;
990 return SourceInfoValue;
992 [Ss][Ii][Nn][Gg][Ll][Ee] {
993 yylval.source_info_value = TTCN_Logger::SINFO_SINGLE;
994 return SourceInfoValue;
996 [Ss][Tt][Aa][Cc][Kk] {
997 yylval.source_info_value = TTCN_Logger::SINFO_STACK;
998 return SourceInfoValue;
1001 yylval.bool_val = TRUE;
1005 yylval.bool_val = FALSE;
1009 yylval.emergency_logging_behaviour_value = TTCN_Logger::BUFFER_ALL;
1010 return EmergencyLoggingBehaviourValue;
1012 [Bb]uffer[Mm]asked {
1013 yylval.emergency_logging_behaviour_value = TTCN_Logger::BUFFER_MASKED;
1014 return EmergencyLoggingBehaviourValue;
1017 [Cc]ompact return Compact;
1018 [Dd]etailed return Detailed;
1019 [Ss]ub[Cc]ategories return SubCategories;
1021 [Ee]rror return Error;
1023 [Ss]top return Stop;
1025 [Rr]etry return Retry;
1027 [Dd]elete return Delete;
1032 [Dd]isable[Pp]rofiler return DisableProfilerKeyword;
1033 [Dd]isable[Cc]overage return DisableCoverageKeyword;
1034 [Dd]ata[Bb]ase[Ff]ile return DatabaseFileKeyword;
1035 [Aa]ggregate[Dd]ata return AggregateDataKeyword;
1036 [Ss]tatistics[Ff]ile return StatisticsFileKeyword;
1037 [Dd]isable[Ss]tatistics return DisableStatisticsKeyword;
1038 [Ss]tatistics[Ff]ilter return StatisticsFilterKeyword;
1039 [Ss]tart[Aa]utomatically return StartAutomaticallyKeyword;
1040 [Nn]et[Ll]ine[Tt]imes return NetLineTimesKeyword;
1041 [Nn]et[Ff]unction[Tt]imes return NetFunctionTimesKeyword;
1043 /* statistics filters */
1044 [Nn]umber[Oo]f[Ll]ines {
1045 yylval.uint_val = Profiler_Tools::STATS_NUMBER_OF_LINES;
1046 return ProfilerStatsFlag;
1048 [Ll]ine[Dd]ata[Rr]aw {
1049 yylval.uint_val = Profiler_Tools::STATS_LINE_DATA_RAW;
1050 return ProfilerStatsFlag;
1052 [Ff]unc[Dd]ata[Rr]aw {
1053 yylval.uint_val = Profiler_Tools::STATS_FUNC_DATA_RAW;
1054 return ProfilerStatsFlag;
1056 [Ll]ine[Aa]vg[Rr]aw {
1057 yylval.uint_val = Profiler_Tools::STATS_LINE_AVG_RAW;
1058 return ProfilerStatsFlag;
1060 [Ff]unc[Aa]vg[Rr]aw {
1061 yylval.uint_val = Profiler_Tools::STATS_FUNC_AVG_RAW;
1062 return ProfilerStatsFlag;
1064 [Ll]ine[Tt]imes[Ss]orted[Bb]y[Mm]od {
1065 yylval.uint_val = Profiler_Tools::STATS_LINE_TIMES_SORTED_BY_MOD;
1066 return ProfilerStatsFlag;
1068 [Ff]unc[Tt]imes[Ss]orted[Bb]y[Mm]od {
1069 yylval.uint_val = Profiler_Tools::STATS_FUNC_TIMES_SORTED_BY_MOD;
1070 return ProfilerStatsFlag;
1072 [Ll]ine[Tt]imes[Ss]orted[Tt]otal {
1073 yylval.uint_val = Profiler_Tools::STATS_LINE_TIMES_SORTED_TOTAL;
1074 return ProfilerStatsFlag;
1076 [Ff]unc[Tt]imes[Ss]orted[Tt]otal {
1077 yylval.uint_val = Profiler_Tools::STATS_FUNC_TIMES_SORTED_TOTAL;
1078 return ProfilerStatsFlag;
1080 [Ll]ine[Cc]ount[Ss]orted[Bb]y[Mm]od {
1081 yylval.uint_val = Profiler_Tools::STATS_LINE_COUNT_SORTED_BY_MOD;
1082 return ProfilerStatsFlag;
1084 [Ff]unc[Cc]ount[Ss]orted[Bb]y[Mm]od {
1085 yylval.uint_val = Profiler_Tools::STATS_FUNC_COUNT_SORTED_BY_MOD;
1086 return ProfilerStatsFlag;
1088 [Ll]ine[Cc]ount[Ss]orted[Tt]otal {
1089 yylval.uint_val = Profiler_Tools::STATS_LINE_COUNT_SORTED_TOTAL;
1090 return ProfilerStatsFlag;
1092 [Ff]unc[Cc]ount[Ss]orted[Tt]otal {
1093 yylval.uint_val = Profiler_Tools::STATS_FUNC_COUNT_SORTED_TOTAL;
1094 return ProfilerStatsFlag;
1096 [Ll]ine[Aa]vg[Ss]orted[Bb]y[Mm]od {
1097 yylval.uint_val = Profiler_Tools::STATS_LINE_AVG_SORTED_BY_MOD;
1098 return ProfilerStatsFlag;
1100 [Ff]unc[Aa]vg[Ss]orted[Bb]y[Mm]od {
1101 yylval.uint_val = Profiler_Tools::STATS_FUNC_AVG_SORTED_BY_MOD;
1102 return ProfilerStatsFlag;
1104 [Ll]ine[Aa]vg[Ss]orted[Tt]otal {
1105 yylval.uint_val = Profiler_Tools::STATS_LINE_AVG_SORTED_TOTAL;
1106 return ProfilerStatsFlag;
1108 [Ff]unc[Aa]vg[Ss]orted[Tt]otal {
1109 yylval.uint_val = Profiler_Tools::STATS_FUNC_AVG_SORTED_TOTAL;
1110 return ProfilerStatsFlag;
1112 [Tt]op10[Ll]ine[Tt]imes {
1113 yylval.uint_val = Profiler_Tools::STATS_TOP10_LINE_TIMES;
1114 return ProfilerStatsFlag;
1116 [Tt]op10[Ff]unc[Tt]imes {
1117 yylval.uint_val = Profiler_Tools::STATS_TOP10_FUNC_TIMES;
1118 return ProfilerStatsFlag;
1120 [Tt]op10[Ll]ine[Cc]ount {
1121 yylval.uint_val = Profiler_Tools::STATS_TOP10_LINE_COUNT;
1122 return ProfilerStatsFlag;
1124 [Tt]op10[Ff]unc[Cc]ount {
1125 yylval.uint_val = Profiler_Tools::STATS_TOP10_FUNC_COUNT;
1126 return ProfilerStatsFlag;
1128 [Tt]op10[Ll]ine[Aa]vg {
1129 yylval.uint_val = Profiler_Tools::STATS_TOP10_LINE_AVG;
1130 return ProfilerStatsFlag;
1132 [Tt]op10[Ff]unc[Aa]vg {
1133 yylval.uint_val = Profiler_Tools::STATS_TOP10_FUNC_AVG;
1134 return ProfilerStatsFlag;
1137 yylval.uint_val = Profiler_Tools::STATS_UNUSED_LINES;
1138 return ProfilerStatsFlag;
1141 yylval.uint_val = Profiler_Tools::STATS_UNUSED_FUNC;
1142 return ProfilerStatsFlag;
1144 [Aa]ll[Rr]aw[Dd]ata {
1145 yylval.uint_val = Profiler_Tools::STATS_ALL_RAW_DATA;
1146 return ProfilerStatsFlag;
1148 [Ll]ine[Dd]ata[Ss]orted[Bb]y[Mm]od {
1149 yylval.uint_val = Profiler_Tools::STATS_LINE_DATA_SORTED_BY_MOD;
1150 return ProfilerStatsFlag;
1152 [Ff]unc[Dd]ata[Ss]orted[Bb]y[Mm]od {
1153 yylval.uint_val = Profiler_Tools::STATS_FUNC_DATA_SORTED_BY_MOD;
1154 return ProfilerStatsFlag;
1156 [Ll]ine[Dd]ata[Ss]orted[Tt]otal {
1157 yylval.uint_val = Profiler_Tools::STATS_LINE_DATA_SORTED_TOTAL;
1158 return ProfilerStatsFlag;
1160 [Ff]unc[Dd]ata[Ss]orted[Tt]otal {
1161 yylval.uint_val = Profiler_Tools::STATS_FUNC_DATA_SORTED_TOTAL;
1162 return ProfilerStatsFlag;
1164 [Ll]ine[Dd]ata[Ss]orted {
1165 yylval.uint_val = Profiler_Tools::STATS_LINE_DATA_SORTED;
1166 return ProfilerStatsFlag;
1168 [Ff]unc[Dd]ata[Ss]orted {
1169 yylval.uint_val = Profiler_Tools::STATS_FUNC_DATA_SORTED;
1170 return ProfilerStatsFlag;
1172 [Aa]ll[Dd]ata[Ss]orted {
1173 yylval.uint_val = Profiler_Tools::STATS_ALL_DATA_SORTED;
1174 return ProfilerStatsFlag;
1176 [Tt]op10[Ll]ine[Dd]ata {
1177 yylval.uint_val = Profiler_Tools::STATS_TOP10_LINE_DATA;
1178 return ProfilerStatsFlag;
1180 [Tt]op10[Ff]unc[Dd]ata {
1181 yylval.uint_val = Profiler_Tools::STATS_TOP10_FUNC_DATA;
1182 return ProfilerStatsFlag;
1184 [Tt]op10[Aa]ll[Dd]ata {
1185 yylval.uint_val = Profiler_Tools::STATS_TOP10_ALL_DATA;
1186 return ProfilerStatsFlag;
1189 yylval.uint_val = Profiler_Tools::STATS_UNUSED_DATA;
1190 return ProfilerStatsFlag;
1193 yylval.uint_val = Profiler_Tools::STATS_ALL;
1194 return ProfilerStatsFlag;
1198 <SC_EXECUTE>control return ControlKeyword;
1200 <SC_EXTERNAL_COMMANDS>
1202 [Bb]egin[Cc]ontrol[Pp]art return BeginControlPart;
1203 [Ee]nd[Cc]ontrol[Pp]art return EndControlPart;
1204 [Bb]egin[Tt]est[Cc]ase return BeginTestCase;
1205 [Ee]nd[Tt]est[Cc]ase return EndTestCase;
1208 <SC_MAIN_CONTROLLER>
1210 [Ll]ocal[Aa]ddress return LocalAddress;
1211 [Tt][Cc][Pp][Pp]ort return TCPPort;
1212 [Kk]ill[Tt]imer return KillTimer;
1213 [Nn]um[Hh][Cc]s return NumHCs;
1214 [Uu]nix[Ss]ockets[Ee]nabled return UnixSocketEnabled;
1215 [Yy][Ee][Ss] return YesToken;
1216 [Nn][Oo] return NoToken;
1220 yylval.str_val = mcopystr(yytext);
1224 <SC_MODULE_PARAMETERS>{ASN1LOWERIDENTIFIER} {
1225 yylval.str_val = mcopystr(yytext);
1226 for (size_t i = 0; i < yyleng; i++) {
1227 if (yylval.str_val[i] == '-') yylval.str_val[i] = '_';
1229 TTCN_warning("In line %d of configuration file: `%s' is not a valid TTCN-3 "
1230 "identifier. Did you mean `%s'?", current_line, yytext, yylval.str_val);
1231 return ASN1LowerIdentifier;
1234 <SC_GROUPS,SC_COMPONENTS,SC_MAIN_CONTROLLER>{DNSNAME}|{IPV6} return DNSName;
1235 /* Information is discarded ! */
1237 <SC_STRING2TTCN_COMPONENT>{COMPONENT} {
1238 /* Ignore the component name, just return its number */
1239 size_t len = strlen(yytext);
1240 size_t pos = len - 1;
1241 while(yytext[pos] != '(' && pos != 0) {
1244 char* comp_num_str = mcopystrn(yytext + pos + 1, len - pos - 1);
1245 yylval.int_val = new int_val_t(comp_num_str);
1251 if (config_defines != NULL) {
1252 char *macroname = get_macro_id_from_ref(yytext);
1254 const char *macrovalue =
1255 string_map_get_bykey(config_defines, macroname, ¯olen);
1256 if (macrovalue != NULL) {
1257 if (!strcmp(macrovalue, "true")) yylval.bool_val = TRUE;
1258 else if (!strcmp(macrovalue, "false")) yylval.bool_val = FALSE;
1260 config_process_error_f("Macro `%s' cannot be interpreted as boolean "
1261 "value: `%s'", macroname, macrovalue);
1262 yylval.bool_val = FALSE;
1265 config_process_error_f("No macro or environmental variable defined"
1266 " with name `%s'", macroname);
1267 yylval.bool_val = FALSE;
1271 config_process_error("Internal error: Macro reference cannot be used in "
1273 yylval.bool_val = FALSE;
1275 return BooleanValue;
1279 if (config_defines != NULL) {
1280 char *macroname = get_macro_id_from_ref(yytext);
1282 const char *macrovalue =
1283 string_map_get_bykey(config_defines, macroname, ¯olen);
1284 if (macrovalue != NULL) {
1285 if (string_is_int(macrovalue, macrolen))
1286 yylval.int_val = new int_val_t(macrovalue);
1288 config_process_error_f("Macro `%s' cannot be interpreted as integer "
1289 "value: `%s'", macroname, macrovalue);
1290 yylval.int_val = new int_val_t((RInt)0);
1293 config_process_error_f("No macro or environmental variable defined"
1294 " with name `%s'", macroname);
1295 yylval.int_val = new int_val_t((RInt)0);
1299 config_process_error("Internal error: Macro reference cannot be used in "
1301 yylval.int_val = new int_val_t((RInt)0);
1303 if (YY_START == SC_MODULE_PARAMETERS) {
1304 // return a different token for module parameters so it doesn't conflict with references
1311 if (config_defines != NULL) {
1312 char *macroname = get_macro_id_from_ref(yytext);
1314 const char *macrovalue =
1315 string_map_get_bykey(config_defines, macroname, ¯olen);
1316 if (macrovalue != NULL) {
1317 if (string_is_float(macrovalue, macrolen))
1318 yylval.float_val = atof(macrovalue);
1320 config_process_error_f("Macro `%s' cannot be interpreted as float value: "
1321 "`%s'", macroname, macrovalue);
1322 yylval.float_val = 0.0;
1325 config_process_error_f("No macro or environmental variable defined"
1326 " with name `%s'", macroname);
1327 yylval.float_val = 0.0;
1331 config_process_error("Internal error: Macro reference cannot be used in "
1333 yylval.float_val = 0.0;
1335 if (YY_START == SC_MODULE_PARAMETERS) {
1336 // return a different token for module parameters so it doesn't conflict with references
1343 if (config_defines != NULL) {
1344 char *macroname = get_macro_id_from_ref(yytext);
1346 const char *macrovalue =
1347 string_map_get_bykey(config_defines, macroname, ¯olen);
1348 boolean is_asn = FALSE;
1349 if (macrovalue != NULL) {
1350 if (string_is_id(macrovalue, macrolen)) {
1351 yylval.str_val = mcopystr(macrovalue);
1352 for (size_t i = 0; i < macrolen; i++) {
1353 if (yylval.str_val[i]=='-') {
1354 yylval.str_val[i] = '_';
1359 TTCN_warning("In line %d of configuration file: `%s' is not a valid"
1360 " TTCN-3 identifier. Did you mean `%s'?",
1361 current_line, macrovalue, yylval.str_val);
1363 config_process_error_f("Macro `%s' cannot be interpreted as identifier: "
1364 "`%s'", macroname, macrovalue);
1365 yylval.str_val = memptystr();
1368 config_process_error_f("No macro or environmental variable defined with "
1369 "name `%s'", macroname);
1370 yylval.str_val = memptystr();
1373 return is_asn ? ASN1LowerIdentifier : Identifier;
1375 config_process_error("Internal error: Macro reference cannot be used in "
1377 yylval.str_val = memptystr();
1383 if (config_defines == NULL) {
1384 config_process_error("Internal error: Macro reference cannot be used in "
1386 yylval.charstring_val.n_chars = 0;
1387 yylval.charstring_val.chars_ptr = memptystr();
1388 if (YY_START == SC_MODULE_PARAMETERS) {
1389 // return a different token for module parameters so it doesn't conflict with references
1396 if (yytext[1] == '{') macroname = get_macro_id_from_ref(yytext);
1397 else macroname = mcopystr(yytext + 1);
1399 const char *macrovalue = string_map_get_bykey
1400 (config_defines, macroname, ¯olen);
1402 if (macrovalue == NULL) {
1403 config_process_error_f("No macro or environmental variable defined with name "
1405 yylval.charstring_val.n_chars=0;
1406 yylval.charstring_val.chars_ptr=memptystr();
1408 if (YY_START == SC_MODULE_PARAMETERS) {
1409 // return a different token for module parameters so it doesn't conflict with references
1415 if (macrolen > 0 && macrovalue[0] == '{') { // structured
1416 main_buffer = YY_CURRENT_BUFFER;
1417 expansion_buffer = yy_scan_string(macrovalue);
1418 yy_switch_to_buffer(expansion_buffer);
1421 yylval.charstring_val.n_chars=macrolen;
1422 yylval.charstring_val.chars_ptr=(char*)Malloc(macrolen+1);
1423 memcpy(yylval.charstring_val.chars_ptr, macrovalue, macrolen+1);
1425 if (YY_START == SC_MODULE_PARAMETERS) {
1426 // return a different token for module parameters so it doesn't conflict with references
1434 if (config_defines != NULL) {
1435 char *macroname = get_macro_id_from_ref(yytext);
1437 const char *macrovalue =
1438 string_map_get_bykey(config_defines, macroname, ¯olen);
1439 if (macrovalue != NULL) {
1440 if (string_is_bstr(macrovalue, macrolen)) {
1441 yylval.bitstring_val.n_bits = macrolen;
1442 int n_bytes = (yylval.bitstring_val.n_bits + 7) / 8;
1443 yylval.bitstring_val.bits_ptr = (unsigned char *)Malloc(n_bytes);
1444 memset(yylval.bitstring_val.bits_ptr, 0, n_bytes);
1445 for (int i = 0; i < yylval.bitstring_val.n_bits; i++)
1446 if (macrovalue[i] == '1')
1447 yylval.bitstring_val.bits_ptr[i/8] |= 1 << (i % 8);
1449 config_process_error_f("Macro `%s' cannot be interpreted as bitstring "
1450 "value: `%s'", macroname, macrovalue);
1451 yylval.bitstring_val.n_bits = 0;
1452 yylval.bitstring_val.bits_ptr = NULL;
1455 config_process_error_f("No macro or environmental variable defined with "
1456 "name `%s'", macroname);
1457 yylval.bitstring_val.n_bits = 0;
1458 yylval.bitstring_val.bits_ptr = NULL;
1462 config_process_error_f("Internal error: Macro reference cannot be used in "
1464 yylval.bitstring_val.n_bits = 0;
1465 yylval.bitstring_val.bits_ptr = NULL;
1471 if (config_defines != NULL) {
1472 char *macroname = get_macro_id_from_ref(yytext);
1474 const char *macrovalue =
1475 string_map_get_bykey(config_defines, macroname, ¯olen);
1476 if (macrovalue != NULL) {
1477 if(string_is_hstr(macrovalue, macrolen)) {
1478 yylval.hexstring_val.n_nibbles = macrolen;
1479 int n_bytes = (yylval.hexstring_val.n_nibbles + 1) / 2;
1480 yylval.hexstring_val.nibbles_ptr = (unsigned char *)Malloc(n_bytes);
1481 memset(yylval.hexstring_val.nibbles_ptr, 0, n_bytes);
1482 for (int i = 0; i < yylval.hexstring_val.n_nibbles; i++) {
1483 unsigned int hex_digit;
1484 sscanf(macrovalue+i, "%1x", &hex_digit);
1485 if(i % 2) yylval.hexstring_val.nibbles_ptr[i/2] |=
1487 else yylval.hexstring_val.nibbles_ptr[i/2] |= hex_digit;
1490 config_process_error_f("Macro `%s' cannot be interpreted as hexstring "
1491 "value: `%s'", macroname, macrovalue);
1492 yylval.hexstring_val.n_nibbles = 0;
1493 yylval.hexstring_val.nibbles_ptr = NULL;
1496 config_process_error_f("No macro or environmental variable defined with "
1497 "name `%s'", macroname);
1498 yylval.hexstring_val.n_nibbles = 0;
1499 yylval.hexstring_val.nibbles_ptr = NULL;
1503 config_process_error("Internal error: Macro reference cannot be used in "
1505 yylval.hexstring_val.n_nibbles = 0;
1506 yylval.hexstring_val.nibbles_ptr = NULL;
1512 if (config_defines != NULL) {
1513 char *macroname = get_macro_id_from_ref(yytext);
1515 const char *macrovalue =
1516 string_map_get_bykey(config_defines, macroname, ¯olen);
1517 if (macrovalue != NULL) {
1518 if (string_is_ostr(macrovalue, macrolen)) {
1519 yylval.octetstring_val.n_octets = macrolen / 2;
1520 yylval.octetstring_val.octets_ptr = (unsigned char *)
1521 Malloc(yylval.octetstring_val.n_octets);
1522 for (int i = 0; i < yylval.octetstring_val.n_octets; i++) {
1523 unsigned int this_octet;
1524 sscanf(macrovalue+2*i, "%2x", &this_octet);
1525 yylval.octetstring_val.octets_ptr[i] = this_octet;
1528 config_process_error_f("Macro `%s' cannot be interpreted as octetstring "
1529 "value: `%s'", macroname, macrovalue);
1530 yylval.octetstring_val.n_octets = 0;
1531 yylval.octetstring_val.octets_ptr = NULL;
1534 config_process_error_f("No macro or environmental variable defined with "
1535 "name `%s'", macroname);
1536 yylval.octetstring_val.n_octets = 0;
1537 yylval.octetstring_val.octets_ptr = NULL;
1541 config_process_error_f("Internal error: Macro reference cannot be used in "
1543 yylval.octetstring_val.n_octets = 0;
1544 yylval.octetstring_val.octets_ptr = NULL;
1550 if (config_defines != NULL) {
1551 char *macroname = get_macro_id_from_ref(yytext);
1553 const char *macrovalue =
1554 string_map_get_bykey(config_defines, macroname, ¯olen);
1555 if (macrovalue != NULL) {
1556 yylval.octetstring_val.n_octets=macrolen;
1557 yylval.octetstring_val.octets_ptr = (unsigned char*)Malloc(macrolen);
1558 memcpy(yylval.octetstring_val.octets_ptr, macrovalue, macrolen);
1561 config_process_error_f("No macro or environmental variable defined with "
1562 "name `%s'", macroname);
1563 yylval.octetstring_val.n_octets = 0;
1564 yylval.octetstring_val.octets_ptr = NULL;
1568 config_process_error("Internal error: Macro reference cannot be used in "
1570 yylval.octetstring_val.n_octets = 0;
1571 yylval.octetstring_val.octets_ptr = NULL;
1577 if (config_defines != NULL) {
1578 char *macroname = get_macro_id_from_ref(yytext);
1580 const char *macrovalue =
1581 string_map_get_bykey(config_defines, macroname, ¯olen);
1582 if (macrovalue != NULL) {
1583 if (!string_is_hostname(macrovalue, macrolen)) {
1584 config_process_error_f("Macro `%s' cannot be interpreted as host name: "
1585 "`%s'", macroname, macrovalue);
1588 config_process_error_f("No macro or environmental variable defined with "
1589 "name `%s'", macroname);
1593 config_process_error("Internal error: Macro reference cannot be used in "
1599 ":="|"=" return AssignmentChar;
1600 "&=" return ConcatChar;
1603 if (expansion_buffer) {
1604 yy_switch_to_buffer(main_buffer);
1605 yy_delete_buffer(expansion_buffer);
1606 expansion_buffer = NULL;
1608 if (include_chain->size() > 1) {
1609 yy_delete_buffer(YY_CURRENT_BUFFER);
1610 fclose(include_chain->back().fp);
1611 include_chain->pop_back();
1612 yy_switch_to_buffer(include_chain->back().buffer_state);
1613 current_line = include_chain->back().line_number;
1614 BEGIN(SC_ORDERED_INCLUDE);
1629 void reset_config_process_lex(const char* fname)
1631 if (!include_chain) {
1632 include_chain = new std::deque<IncludeElem<YY_BUFFER_STATE> >();
1637 include_chain->push_back(IncludeElem<YY_BUFFER_STATE>(std::string(fname), config_process_in));
1641 void config_process_close() {
1642 delete include_chain;
1643 include_chain = NULL;
1646 int config_process_get_current_line()
1648 return current_line;