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
20 * Szabo, Janos Zoltan – initial implementation
22 * Zalanyi, Balazs Andor
24 ******************************************************************************/
26 %option never-interactive
38 #include "../common/cfg_process_utils.hh"
39 #include "../common/Path2.hh"
41 #include "../common/memory.h"
43 #include "Parameters.h"
44 #include "Param_Types.hh"
46 #include "LoggingBits.hh"
47 #include "LoggingParam.hh"
49 #include "config_process.tab.hh"
50 #include "../common/config_preproc.h"
51 #include "../common/path.h"
53 #include "../common/dbgnew.hh"
55 #include "Profiler.hh"
57 extern string_map_t *config_defines;
59 #define yylval config_process_lval
61 static int current_line;
63 static YY_BUFFER_STATE main_buffer = NULL;
64 /* This buffer is used for macro expansion */
65 static YY_BUFFER_STATE expansion_buffer = NULL;
67 static std::deque<IncludeElem<YY_BUFFER_STATE> >* include_chain = NULL;
69 static void set_ret_val_cstr(const std::string& cstring) {
70 param_charstring_t& ch_val = yylval.charstring_val;
71 ch_val.n_chars = cstring.size();
72 ch_val.chars_ptr = (char*) Malloc(ch_val.n_chars + 1);
73 memcpy(ch_val.chars_ptr, cstring.c_str(), cstring.size() + 1);
76 std::string get_cfg_process_current_file() {
77 if (include_chain && !include_chain->empty()) {
78 return include_chain->back().get_full_path();
89 LINECOMMENT ("//"|"#")[^\r\n]*{NEWLINE}
91 NUMBER 0|([1-9][0-9]*)
93 FLOAT [+-]?({NUMBER}\.[0-9]+)|((({NUMBER}(\.[0-9]+)?)|(\.[0-9]+))[Ee][+-]?{NUMBER})
98 BITSTRINGMATCH '{BINMATCH}*'B
99 BITSTRING_BAD '[^']*'B
103 HEXMATCH [0-9A-Fa-f\?\*]
104 HEXSTRINGMATCH '{HEXMATCH}*'H
105 HEXSTRING_BAD '[^']*'H
108 OCTETSTRING '{OCT}*'O
109 OCTMATCH {HEX}{HEX}|\?|\*
110 OCTETSTRINGMATCH '{OCTMATCH}*'O
111 OCTETSTRING_BAD '[^']*'O
113 BINSTRING_BAD '[^']*'
115 TTCN3IDENTIFIER [A-Za-z][A-Za-z0-9_]*
116 ASN1LOWERIDENTIFIER [a-z](-?[A-Za-z0-9]+)*
118 COMPONENT .*\({NUMBER}\)
120 MACRO_CSTR \${TTCN3IDENTIFIER}|\$"{"{WS}{TTCN3IDENTIFIER}{WS}(","{WS}charstring{WS})?"}"
121 MACRO_BOOL \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}boolean{WS}"}"
122 MACRO_FLOAT \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}float{WS}"}"
123 MACRO_ID \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}identifier{WS}"}"
124 MACRO_INT \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}integer{WS}"}"
125 MACRO_BSTR \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}bitstring{WS}"}"
126 MACRO_HSTR \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}hexstring{WS}"}"
127 MACRO_OSTR \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}octetstring{WS}"}"
128 MACRO_BINARY \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}binaryoctet{WS}"}"
129 MACRO_HOSTNAME \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}hostname{WS}"}"
131 HOSTNAME [A-Za-z0-9]([A-Za-z0-9_\-]*[A-Za-z0-9])?
132 DNSNAME {HOSTNAME}(\.{HOSTNAME})*\.?
134 /* Example: fe80::c002:37ff:fe6c:0%fastethernet0/0 */
135 IPV6 [0-9A-Fa-f:.]+(%[0-9A-Za-z]+)?
137 UID [uU][+]?[0-9A-Fa-f]{1,8}
139 TTCNSTRINGPARSING "$#&&&(#TTCNSTRINGPARSING$#&&^#% "
140 TTCNSTRINGPARSING_COMPONENT "$#&&&(#TTCNSTRINGPARSING_COMPONENT$#&&^#% "
142 %x SC_commentblock SC_cstring SC_DEFINE
143 %s SC_MODULE_PARAMETERS SC_LOGGING SC_TESTPORT_PARAMETERS SC_EXECUTE SC_GROUPS
144 %s SC_COMPONENTS SC_EXTERNAL_COMMANDS SC_MAIN_CONTROLLER SC_INCLUDE SC_ORDERED_INCLUDE
145 %s SC_STRING2TTCN_COMPONENT SC_PROFILER SC_CHAR_KEYWORD
149 int caller_state = INITIAL;
151 int cstring_start = -1;
153 /* Eat up comments and whitespaces */
156 caller_state = YY_START;
157 BEGIN(SC_commentblock);
161 "*/" BEGIN(caller_state);
162 {NEWLINE} current_line++;
165 config_process_error("Unterminated block comment (missing */ at the "
173 {LINECOMMENT} current_line++;
175 {TTCNSTRINGPARSING} {
176 if (Ttcn_String_Parsing::happening() || Debugger_Value_Parsing::happening()) {
177 BEGIN(SC_MODULE_PARAMETERS);
178 return TtcnStringParsingKeyword;
180 config_process_error("Invalid character sequence encountered.");
184 {TTCNSTRINGPARSING_COMPONENT} {
185 if (Ttcn_String_Parsing::happening()) {
186 BEGIN(SC_STRING2TTCN_COMPONENT);
187 return TtcnStringParsingKeyword;
189 config_process_error("Invalid character sequence encountered.");
193 /* Section delimiters */
195 <*>"["{WS}MODULE_PARAMETERS{WS}"]" {
196 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
197 BEGIN(SC_MODULE_PARAMETERS);
198 return ModuleParametersKeyword;
202 <*>"["{WS}LOGGING{WS}"]" {
203 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
205 return LoggingKeyword;
209 <*>"["{WS}PROFILER{WS}"]" {
210 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
212 return ProfilerKeyword;
216 <*>"["{WS}TESTPORT_PARAMETERS{WS}"]" {
217 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
218 BEGIN(SC_TESTPORT_PARAMETERS);
219 return TestportParametersKeyword;
223 <*>"["{WS}EXECUTE{WS}"]" {
224 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
226 return ExecuteKeyword;
230 <*>"["{WS}EXTERNAL_COMMANDS{WS}"]" {
231 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
232 BEGIN(SC_EXTERNAL_COMMANDS);
233 return ExternalCommandsKeyword;
237 <*>"["{WS}GROUPS{WS}"]" {
238 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
240 return GroupsKeyword;
244 <*>"["{WS}COMPONENTS{WS}"]" {
245 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
246 BEGIN(SC_COMPONENTS);
247 return ComponentsKeyword;
251 <*>"["{WS}MAIN_CONTROLLER{WS}"]" {
252 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
253 BEGIN(SC_MAIN_CONTROLLER);
254 return MainControllerKeyword;
258 <*>"["{WS}INCLUDE{WS}"]" {
259 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
261 return IncludeKeyword;
265 <*>"["{WS}ORDERED_INCLUDE{WS}"]" {
266 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
267 BEGIN(SC_ORDERED_INCLUDE);
271 <*>"["{WS}DEFINE{WS}"]" {
272 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
274 return DefineKeyword;
278 /* Rules for SC_DEFINE must precede everything else */
283 caller_state = SC_DEFINE;
284 BEGIN(SC_commentblock);
288 caller_state = SC_DEFINE;
291 cstring_start = current_line;
294 {LINECOMMENT}|{NEWLINE} current_line++;
298 . /* eat unnecessary chars */
302 <SC_PROFILER>{HEX}+ {
303 /* numeric statistics filter (check this before checking for NUMBERs) */
305 while(0 != *yytext) {
306 yylval.uint_val *= 16;
307 if ('0' <= *yytext && '9' >= *yytext) {
308 yylval.uint_val += *yytext - '0';
310 else if ('a' <= *yytext && 'f' >= *yytext) {
311 yylval.uint_val += *yytext - 'a' + 10;
314 yylval.uint_val += *yytext - 'A' + 10;
318 return ProfilerStatsFlag;
324 yylval.int_val = new int_val_t(yytext);
325 if (YY_START == SC_MODULE_PARAMETERS || YY_START == SC_CHAR_KEYWORD) {
326 // return a different token for module parameters so it doesn't conflict with references
333 yylval.float_val = atof(yytext);
334 if (YY_START == SC_MODULE_PARAMETERS || YY_START == SC_CHAR_KEYWORD) {
335 // return a different token for module parameters so it doesn't conflict with references
342 yylval.bitstring_val.n_bits = yyleng - 3;
343 int n_bytes = (yylval.bitstring_val.n_bits + 7) / 8;
344 yylval.bitstring_val.bits_ptr = (unsigned char *)Malloc(n_bytes);
345 memset(yylval.bitstring_val.bits_ptr, 0, n_bytes);
346 for (int i = 0; i < yylval.bitstring_val.n_bits; i++)
347 if (yytext[i+1] == '1')
348 yylval.bitstring_val.bits_ptr[i/8] |= 1 << (i % 8);
353 yylval.str_val = mcopystrn(yytext+1, yyleng-3);
358 config_process_error("Invalid bitstring value.");
359 yylval.bitstring_val.n_bits = 0;
360 yylval.bitstring_val.bits_ptr = NULL;
365 yylval.hexstring_val.n_nibbles = yyleng - 3;
366 int n_bytes = (yylval.hexstring_val.n_nibbles + 1) / 2;
367 yylval.hexstring_val.nibbles_ptr = (unsigned char *)Malloc(n_bytes);
368 memset(yylval.hexstring_val.nibbles_ptr, 0, n_bytes);
369 for (int i = 0; i < yylval.hexstring_val.n_nibbles; i++) {
370 unsigned int hex_digit;
371 sscanf(yytext+i+1, "%1x", &hex_digit);
372 if(i % 2) yylval.hexstring_val.nibbles_ptr[i/2] |=
374 else yylval.hexstring_val.nibbles_ptr[i/2] |= hex_digit;
380 yylval.str_val = mcopystrn(yytext+1, yyleng-3);
385 config_process_error("Invalid hexstring value.");
386 yylval.hexstring_val.n_nibbles = 0;
387 yylval.hexstring_val.nibbles_ptr = NULL;
392 yylval.octetstring_val.n_octets = (yyleng - 3) / 2;
393 yylval.octetstring_val.octets_ptr = (unsigned char *)
394 Malloc(yylval.octetstring_val.n_octets);
396 for (int i = 0; i < yylval.octetstring_val.n_octets; i++) {
397 unsigned int this_octet;
398 sscanf(yytext+2*i+1, "%2x", &this_octet);
399 yylval.octetstring_val.octets_ptr[i] = this_octet;
405 yylval.str_val = mcopystrn(yytext+1, yyleng-3);
410 config_process_error("Invalid octetstring value.");
411 yylval.octetstring_val.n_octets = 0;
412 yylval.octetstring_val.octets_ptr = NULL;
416 {BINSTRING_BAD} config_process_error("Invalid string value.");
418 ' config_process_error("Unmatched ' character.");
421 caller_state = YY_START;
424 cstring_start = current_line;
431 /* end of the string */
433 switch (caller_state) {
437 case SC_ORDERED_INCLUDE:
439 std::string error_msg = switch_lexer(include_chain, cstring,
440 YY_CURRENT_BUFFER, yy_create_buffer, yy_switch_to_buffer,
441 current_line, YY_BUF_SIZE);
442 if (error_msg.empty()) {
445 config_process_error(error_msg.c_str());
450 set_ret_val_cstr(cstring);
451 if (caller_state == SC_MODULE_PARAMETERS || caller_state == SC_CHAR_KEYWORD) {
452 // return a different token for module parameters so it doesn't conflict with references
461 \\[\\'"?] cstring += yytext[1]; /* backslash-quoted \ or " or ' or ? */
462 \\{NEWLINE} current_line++;
472 sscanf(yytext + 1, "%o", &c);
474 config_process_error("Invalid octal character code in string "
476 else if (c == 0 && caller_state != SC_MODULE_PARAMETERS)
477 config_process_error("NUL characters in string literals are "
478 "allowed only in section [MODULE_PARAMETERS].");
483 sscanf(yytext + 2, "%x", &c);
484 if (c == 0 && caller_state != SC_MODULE_PARAMETERS)
485 config_process_error("NUL characters in string literals are "
486 "allowed only in section [MODULE_PARAMETERS].");
490 config_process_error("Invalid escape sequence in string literal.");
493 cstring.append(yytext, yyleng);
496 . cstring += yytext[0];
498 if (cstring_start >=0) {
499 config_process_error_f("Unterminated string literal starting at line %d "
500 "(missing \" at the end of file).", cstring_start);
502 config_process_error("Unterminated string literal (missing \" at the "
506 if (caller_state!=SC_DEFINE) {
507 set_ret_val_cstr(cstring);
508 if (caller_state == SC_MODULE_PARAMETERS || caller_state == SC_CHAR_KEYWORD) {
509 // return a different token for module parameters so it doesn't conflict with references
522 yylval.str_val = mcopystrn(yytext, yyleng);
526 [,] { return *yytext; }
528 [)] { BEGIN(SC_MODULE_PARAMETERS); return *yytext; }
531 /* Section-wide keywords */
533 <SC_MODULE_PARAMETERS>
535 NULL return NULLKeyword;
536 null return nullKeyword;
537 char { BEGIN(SC_CHAR_KEYWORD); return CharKeyword; }
538 objid return ObjIdKeyword;
539 omit return OmitKeyword;
541 yylval.verdict_val = NONE;
545 yylval.verdict_val = PASS;
549 yylval.verdict_val = INCONC;
553 yylval.verdict_val = FAIL;
557 yylval.verdict_val = ERROR;
560 complement return ComplementKeyword;
561 "\.\." return DotDot;
562 superset return SupersetKeyword;
563 subset return SubsetKeyword;
564 pattern return PatternKeyword;
565 permutation return PermutationKeyword;
566 length return LengthKeyword;
567 ifpresent return IfpresentKeyword;
568 infinity return InfinityKeyword;
571 <SC_MODULE_PARAMETERS,SC_LOGGING,SC_PROFILER>
574 yylval.bool_val = TRUE;
578 yylval.bool_val = FALSE;
583 /* We could add SC_LOGGING to make mtc and system special for the logging section too */
584 <SC_MODULE_PARAMETERS,SC_STRING2TTCN_COMPONENT,SC_TESTPORT_PARAMETERS,SC_LOGGING>
586 mtc return MTCKeyword;
587 system return SystemKeyword;
593 [Ll]og[Ff]ile return LogFile;
595 [Ee]mergency[Ll]ogging return EmergencyLogging;
597 [Ee]mergency[Ll]ogging[Bb]ehaviour return EmergencyLoggingBehaviour;
599 [Ee]mergency[Ll]ogging[Mm]ask return EmergencyLoggingMask;
601 [Ee]mergency[Ll]ogging[Ff]or[Ff]ail[Vv]erdict return EmergencyLoggingForFailVerdict;
603 [Ff]ile[Mm]ask return FileMask;
605 [Cc]onsole[Mm]ask return ConsoleMask;
607 [Tt]ime[Ss]tamp[Ff]ormat return TimestampFormat;
608 [Cc]onsole[Tt]ime[Ss]tamp[Ff]ormat return ConsoleTimestampFormat;
610 [Ll]og[Ss]ource[Ii]nfo |
611 [Ss]ource[Ii]nfo[Ff]ormat return SourceInfoFormat;
613 [Aa]ppend[Ff]ile return AppendFile;
615 [Ll]og[Ee]vent[Tt]ypes return LogEventTypes;
617 [Ll]og[Ee]ntity[Nn]ame return LogEntityName;
619 [Ll]og[Ff]ile[Ss]ize return LogFileSize;
621 [Ll]og[Ff]ile[Nn]umber return LogFileNumber;
623 [Dd]isk[Ff]ull[Aa]ction return DiskFullAction;
625 [Mm]atching[Hh]ints return MatchingHints;
627 [Ll]ogger[Pp]lugins return LoggerPlugins;
629 /* Lexer's handling of logging keywords:
631 * For sub-categories and categories with only one member,
632 * LoggingBit is returned and the value is the corresponding
633 * TTCN_Logger::Severity.
635 * For the old categories which now have subcategories, the old keyword
636 * is returned as LoggingBitCollection with the corresponding
637 * _UNQUALIFIED as the semantic value. The parser will construct the
640 * The lexer never returns a token with a Logging_Bits type.
643 yylval.logseverity_val = TTCN_Logger::NOTHING_TO_LOG;
648 yylval.logseverity_val = TTCN_Logger::ACTION_UNQUALIFIED;
652 yylval.logseverity_val = TTCN_Logger::ACTION_UNQUALIFIED;
653 return LoggingBitCollection;
657 yylval.logseverity_val = TTCN_Logger::DEBUG_ENCDEC;
661 yylval.logseverity_val = TTCN_Logger::DEBUG_TESTPORT;
665 yylval.logseverity_val = TTCN_Logger::DEBUG_USER;
669 yylval.logseverity_val = TTCN_Logger::DEBUG_FRAMEWORK;
673 yylval.logseverity_val = TTCN_Logger::DEBUG_UNQUALIFIED;
677 yylval.logseverity_val = TTCN_Logger::DEBUG_UNQUALIFIED;
678 return LoggingBitCollection;
682 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_ACTIVATE;
685 DEFAULTOP_DEACTIVATE {
686 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_DEACTIVATE;
690 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_EXIT;
693 DEFAULTOP_UNQUALIFIED {
694 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_UNQUALIFIED;
698 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_UNQUALIFIED;
699 return LoggingBitCollection;
703 yylval.logseverity_val = TTCN_Logger::ERROR_UNQUALIFIED;
707 yylval.logseverity_val = TTCN_Logger::ERROR_UNQUALIFIED;
708 return LoggingBitCollection;
712 yylval.logseverity_val = TTCN_Logger::EXECUTOR_COMPONENT;
715 EXECUTOR_CONFIGDATA {
716 yylval.logseverity_val = TTCN_Logger::EXECUTOR_CONFIGDATA;
719 EXECUTOR_EXTCOMMAND {
720 yylval.logseverity_val = TTCN_Logger::EXECUTOR_EXTCOMMAND;
723 EXECUTOR_LOGOPTIONS {
724 yylval.logseverity_val = TTCN_Logger::EXECUTOR_LOGOPTIONS;
728 yylval.logseverity_val = TTCN_Logger::EXECUTOR_RUNTIME;
731 EXECUTOR_UNQUALIFIED {
732 yylval.logseverity_val = TTCN_Logger::EXECUTOR_UNQUALIFIED;
736 yylval.logseverity_val = TTCN_Logger::EXECUTOR_UNQUALIFIED;
737 return LoggingBitCollection;
741 yylval.logseverity_val = TTCN_Logger::FUNCTION_RND;
744 FUNCTION_UNQUALIFIED {
745 yylval.logseverity_val = TTCN_Logger::FUNCTION_UNQUALIFIED;
749 yylval.logseverity_val = TTCN_Logger::FUNCTION_UNQUALIFIED;
750 return LoggingBitCollection;
754 yylval.logseverity_val = TTCN_Logger::MATCHING_DONE;
758 yylval.logseverity_val = TTCN_Logger::MATCHING_MCSUCCESS;
762 yylval.logseverity_val = TTCN_Logger::MATCHING_MCUNSUCC;
766 yylval.logseverity_val = TTCN_Logger::MATCHING_MMSUCCESS;
770 yylval.logseverity_val = TTCN_Logger::MATCHING_MMUNSUCC;
774 yylval.logseverity_val = TTCN_Logger::MATCHING_PCSUCCESS;
778 yylval.logseverity_val = TTCN_Logger::MATCHING_PCUNSUCC;
782 yylval.logseverity_val = TTCN_Logger::MATCHING_PMSUCCESS;
786 yylval.logseverity_val = TTCN_Logger::MATCHING_PMUNSUCC;
790 yylval.logseverity_val = TTCN_Logger::MATCHING_PROBLEM;
794 yylval.logseverity_val = TTCN_Logger::MATCHING_TIMEOUT;
797 MATCHING_UNQUALIFIED {
798 yylval.logseverity_val = TTCN_Logger::MATCHING_UNQUALIFIED;
802 yylval.logseverity_val = TTCN_Logger::MATCHING_UNQUALIFIED;
803 return LoggingBitCollection;
807 yylval.logseverity_val = TTCN_Logger::PARALLEL_PORTCONN;
811 yylval.logseverity_val = TTCN_Logger::PARALLEL_PORTMAP;
815 yylval.logseverity_val = TTCN_Logger::PARALLEL_PTC;
818 PARALLEL_UNQUALIFIED {
819 yylval.logseverity_val = TTCN_Logger::PARALLEL_UNQUALIFIED;
823 yylval.logseverity_val = TTCN_Logger::PARALLEL_UNQUALIFIED;
824 return LoggingBitCollection;
828 yylval.logseverity_val = TTCN_Logger::PORTEVENT_DUALRECV;
832 yylval.logseverity_val = TTCN_Logger::PORTEVENT_DUALSEND;
836 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MCRECV;
840 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MCSEND;
844 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MMRECV;
848 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MMSEND;
852 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MQUEUE;
856 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PCIN;
860 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PCOUT;
864 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PMIN;
868 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PMOUT;
872 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PQUEUE;
876 yylval.logseverity_val = TTCN_Logger::PORTEVENT_STATE;
879 PORTEVENT_UNQUALIFIED {
880 yylval.logseverity_val = TTCN_Logger::PORTEVENT_UNQUALIFIED;
884 yylval.logseverity_val = TTCN_Logger::PORTEVENT_UNQUALIFIED;
885 return LoggingBitCollection;
888 STATISTICS_UNQUALIFIED {
889 yylval.logseverity_val = TTCN_Logger::STATISTICS_UNQUALIFIED;
893 yylval.logseverity_val = TTCN_Logger::STATISTICS_VERDICT;
897 yylval.logseverity_val = TTCN_Logger::STATISTICS_UNQUALIFIED;
898 return LoggingBitCollection;
902 yylval.logseverity_val = TTCN_Logger::TESTCASE_FINISH;
906 yylval.logseverity_val = TTCN_Logger::TESTCASE_START;
909 TESTCASE_UNQUALIFIED {
910 yylval.logseverity_val = TTCN_Logger::TESTCASE_UNQUALIFIED;
914 yylval.logseverity_val = TTCN_Logger::TESTCASE_UNQUALIFIED;
915 return LoggingBitCollection;
919 yylval.logseverity_val = TTCN_Logger::TIMEROP_GUARD;
923 yylval.logseverity_val = TTCN_Logger::TIMEROP_READ;
927 yylval.logseverity_val = TTCN_Logger::TIMEROP_START;
931 yylval.logseverity_val = TTCN_Logger::TIMEROP_STOP;
935 yylval.logseverity_val = TTCN_Logger::TIMEROP_TIMEOUT;
938 TIMEROP_UNQUALIFIED {
939 yylval.logseverity_val = TTCN_Logger::TIMEROP_UNQUALIFIED;
943 yylval.logseverity_val = TTCN_Logger::TIMEROP_UNQUALIFIED;
944 return LoggingBitCollection;
948 yylval.logseverity_val = TTCN_Logger::USER_UNQUALIFIED;
952 yylval.logseverity_val = TTCN_Logger::USER_UNQUALIFIED;
953 return LoggingBitCollection;
957 yylval.logseverity_val = TTCN_Logger::VERDICTOP_FINAL;
960 VERDICTOP_GETVERDICT {
961 yylval.logseverity_val = TTCN_Logger::VERDICTOP_GETVERDICT;
964 VERDICTOP_SETVERDICT {
965 yylval.logseverity_val = TTCN_Logger::VERDICTOP_SETVERDICT;
968 VERDICTOP_UNQUALIFIED {
969 yylval.logseverity_val = TTCN_Logger::VERDICTOP_UNQUALIFIED;
973 yylval.logseverity_val = TTCN_Logger::VERDICTOP_UNQUALIFIED;
974 return LoggingBitCollection;
977 WARNING_UNQUALIFIED {
978 yylval.logseverity_val = TTCN_Logger::WARNING_UNQUALIFIED;
982 yylval.logseverity_val = TTCN_Logger::WARNING_UNQUALIFIED;
983 return LoggingBitCollection;
987 yylval.logseverity_val = TTCN_Logger::LOG_ALL_IMPORTANT;
988 return LoggingBitCollection;
992 yylval.timestamp_value = TTCN_Logger::TIMESTAMP_TIME;
993 return TimestampValue;
995 [Dd][Aa][Tt][Ee][Tt][Ii][Mm][Ee] {
996 yylval.timestamp_value = TTCN_Logger::TIMESTAMP_DATETIME;
997 return TimestampValue;
999 [Ss][Ee][Cc][Oo][Nn][Dd][Ss] {
1000 yylval.timestamp_value = TTCN_Logger::TIMESTAMP_SECONDS;
1001 return TimestampValue;
1004 yylval.source_info_value = TTCN_Logger::SINFO_NONE;
1005 return SourceInfoValue;
1007 [Ss][Ii][Nn][Gg][Ll][Ee] {
1008 yylval.source_info_value = TTCN_Logger::SINFO_SINGLE;
1009 return SourceInfoValue;
1011 [Ss][Tt][Aa][Cc][Kk] {
1012 yylval.source_info_value = TTCN_Logger::SINFO_STACK;
1013 return SourceInfoValue;
1016 yylval.bool_val = TRUE;
1020 yylval.bool_val = FALSE;
1024 yylval.emergency_logging_behaviour_value = TTCN_Logger::BUFFER_ALL;
1025 return EmergencyLoggingBehaviourValue;
1027 [Bb]uffer[Mm]asked {
1028 yylval.emergency_logging_behaviour_value = TTCN_Logger::BUFFER_MASKED;
1029 return EmergencyLoggingBehaviourValue;
1032 [Cc]ompact return Compact;
1033 [Dd]etailed return Detailed;
1034 [Ss]ub[Cc]ategories return SubCategories;
1036 [Ee]rror return Error;
1038 [Ss]top return Stop;
1040 [Rr]etry return Retry;
1042 [Dd]elete return Delete;
1047 [Dd]isable[Pp]rofiler return DisableProfilerKeyword;
1048 [Dd]isable[Cc]overage return DisableCoverageKeyword;
1049 [Dd]ata[Bb]ase[Ff]ile return DatabaseFileKeyword;
1050 [Aa]ggregate[Dd]ata return AggregateDataKeyword;
1051 [Ss]tatistics[Ff]ile return StatisticsFileKeyword;
1052 [Dd]isable[Ss]tatistics return DisableStatisticsKeyword;
1053 [Ss]tatistics[Ff]ilter return StatisticsFilterKeyword;
1054 [Ss]tart[Aa]utomatically return StartAutomaticallyKeyword;
1055 [Nn]et[Ll]ine[Tt]imes return NetLineTimesKeyword;
1056 [Nn]et[Ff]unction[Tt]imes return NetFunctionTimesKeyword;
1058 /* statistics filters */
1059 [Nn]umber[Oo]f[Ll]ines {
1060 yylval.uint_val = Profiler_Tools::STATS_NUMBER_OF_LINES;
1061 return ProfilerStatsFlag;
1063 [Ll]ine[Dd]ata[Rr]aw {
1064 yylval.uint_val = Profiler_Tools::STATS_LINE_DATA_RAW;
1065 return ProfilerStatsFlag;
1067 [Ff]unc[Dd]ata[Rr]aw {
1068 yylval.uint_val = Profiler_Tools::STATS_FUNC_DATA_RAW;
1069 return ProfilerStatsFlag;
1071 [Ll]ine[Aa]vg[Rr]aw {
1072 yylval.uint_val = Profiler_Tools::STATS_LINE_AVG_RAW;
1073 return ProfilerStatsFlag;
1075 [Ff]unc[Aa]vg[Rr]aw {
1076 yylval.uint_val = Profiler_Tools::STATS_FUNC_AVG_RAW;
1077 return ProfilerStatsFlag;
1079 [Ll]ine[Tt]imes[Ss]orted[Bb]y[Mm]od {
1080 yylval.uint_val = Profiler_Tools::STATS_LINE_TIMES_SORTED_BY_MOD;
1081 return ProfilerStatsFlag;
1083 [Ff]unc[Tt]imes[Ss]orted[Bb]y[Mm]od {
1084 yylval.uint_val = Profiler_Tools::STATS_FUNC_TIMES_SORTED_BY_MOD;
1085 return ProfilerStatsFlag;
1087 [Ll]ine[Tt]imes[Ss]orted[Tt]otal {
1088 yylval.uint_val = Profiler_Tools::STATS_LINE_TIMES_SORTED_TOTAL;
1089 return ProfilerStatsFlag;
1091 [Ff]unc[Tt]imes[Ss]orted[Tt]otal {
1092 yylval.uint_val = Profiler_Tools::STATS_FUNC_TIMES_SORTED_TOTAL;
1093 return ProfilerStatsFlag;
1095 [Ll]ine[Cc]ount[Ss]orted[Bb]y[Mm]od {
1096 yylval.uint_val = Profiler_Tools::STATS_LINE_COUNT_SORTED_BY_MOD;
1097 return ProfilerStatsFlag;
1099 [Ff]unc[Cc]ount[Ss]orted[Bb]y[Mm]od {
1100 yylval.uint_val = Profiler_Tools::STATS_FUNC_COUNT_SORTED_BY_MOD;
1101 return ProfilerStatsFlag;
1103 [Ll]ine[Cc]ount[Ss]orted[Tt]otal {
1104 yylval.uint_val = Profiler_Tools::STATS_LINE_COUNT_SORTED_TOTAL;
1105 return ProfilerStatsFlag;
1107 [Ff]unc[Cc]ount[Ss]orted[Tt]otal {
1108 yylval.uint_val = Profiler_Tools::STATS_FUNC_COUNT_SORTED_TOTAL;
1109 return ProfilerStatsFlag;
1111 [Ll]ine[Aa]vg[Ss]orted[Bb]y[Mm]od {
1112 yylval.uint_val = Profiler_Tools::STATS_LINE_AVG_SORTED_BY_MOD;
1113 return ProfilerStatsFlag;
1115 [Ff]unc[Aa]vg[Ss]orted[Bb]y[Mm]od {
1116 yylval.uint_val = Profiler_Tools::STATS_FUNC_AVG_SORTED_BY_MOD;
1117 return ProfilerStatsFlag;
1119 [Ll]ine[Aa]vg[Ss]orted[Tt]otal {
1120 yylval.uint_val = Profiler_Tools::STATS_LINE_AVG_SORTED_TOTAL;
1121 return ProfilerStatsFlag;
1123 [Ff]unc[Aa]vg[Ss]orted[Tt]otal {
1124 yylval.uint_val = Profiler_Tools::STATS_FUNC_AVG_SORTED_TOTAL;
1125 return ProfilerStatsFlag;
1127 [Tt]op10[Ll]ine[Tt]imes {
1128 yylval.uint_val = Profiler_Tools::STATS_TOP10_LINE_TIMES;
1129 return ProfilerStatsFlag;
1131 [Tt]op10[Ff]unc[Tt]imes {
1132 yylval.uint_val = Profiler_Tools::STATS_TOP10_FUNC_TIMES;
1133 return ProfilerStatsFlag;
1135 [Tt]op10[Ll]ine[Cc]ount {
1136 yylval.uint_val = Profiler_Tools::STATS_TOP10_LINE_COUNT;
1137 return ProfilerStatsFlag;
1139 [Tt]op10[Ff]unc[Cc]ount {
1140 yylval.uint_val = Profiler_Tools::STATS_TOP10_FUNC_COUNT;
1141 return ProfilerStatsFlag;
1143 [Tt]op10[Ll]ine[Aa]vg {
1144 yylval.uint_val = Profiler_Tools::STATS_TOP10_LINE_AVG;
1145 return ProfilerStatsFlag;
1147 [Tt]op10[Ff]unc[Aa]vg {
1148 yylval.uint_val = Profiler_Tools::STATS_TOP10_FUNC_AVG;
1149 return ProfilerStatsFlag;
1152 yylval.uint_val = Profiler_Tools::STATS_UNUSED_LINES;
1153 return ProfilerStatsFlag;
1156 yylval.uint_val = Profiler_Tools::STATS_UNUSED_FUNC;
1157 return ProfilerStatsFlag;
1159 [Aa]ll[Rr]aw[Dd]ata {
1160 yylval.uint_val = Profiler_Tools::STATS_ALL_RAW_DATA;
1161 return ProfilerStatsFlag;
1163 [Ll]ine[Dd]ata[Ss]orted[Bb]y[Mm]od {
1164 yylval.uint_val = Profiler_Tools::STATS_LINE_DATA_SORTED_BY_MOD;
1165 return ProfilerStatsFlag;
1167 [Ff]unc[Dd]ata[Ss]orted[Bb]y[Mm]od {
1168 yylval.uint_val = Profiler_Tools::STATS_FUNC_DATA_SORTED_BY_MOD;
1169 return ProfilerStatsFlag;
1171 [Ll]ine[Dd]ata[Ss]orted[Tt]otal {
1172 yylval.uint_val = Profiler_Tools::STATS_LINE_DATA_SORTED_TOTAL;
1173 return ProfilerStatsFlag;
1175 [Ff]unc[Dd]ata[Ss]orted[Tt]otal {
1176 yylval.uint_val = Profiler_Tools::STATS_FUNC_DATA_SORTED_TOTAL;
1177 return ProfilerStatsFlag;
1179 [Ll]ine[Dd]ata[Ss]orted {
1180 yylval.uint_val = Profiler_Tools::STATS_LINE_DATA_SORTED;
1181 return ProfilerStatsFlag;
1183 [Ff]unc[Dd]ata[Ss]orted {
1184 yylval.uint_val = Profiler_Tools::STATS_FUNC_DATA_SORTED;
1185 return ProfilerStatsFlag;
1187 [Aa]ll[Dd]ata[Ss]orted {
1188 yylval.uint_val = Profiler_Tools::STATS_ALL_DATA_SORTED;
1189 return ProfilerStatsFlag;
1191 [Tt]op10[Ll]ine[Dd]ata {
1192 yylval.uint_val = Profiler_Tools::STATS_TOP10_LINE_DATA;
1193 return ProfilerStatsFlag;
1195 [Tt]op10[Ff]unc[Dd]ata {
1196 yylval.uint_val = Profiler_Tools::STATS_TOP10_FUNC_DATA;
1197 return ProfilerStatsFlag;
1199 [Tt]op10[Aa]ll[Dd]ata {
1200 yylval.uint_val = Profiler_Tools::STATS_TOP10_ALL_DATA;
1201 return ProfilerStatsFlag;
1204 yylval.uint_val = Profiler_Tools::STATS_UNUSED_DATA;
1205 return ProfilerStatsFlag;
1208 yylval.uint_val = Profiler_Tools::STATS_ALL;
1209 return ProfilerStatsFlag;
1213 <SC_EXECUTE>control return ControlKeyword;
1215 <SC_EXTERNAL_COMMANDS>
1217 [Bb]egin[Cc]ontrol[Pp]art return BeginControlPart;
1218 [Ee]nd[Cc]ontrol[Pp]art return EndControlPart;
1219 [Bb]egin[Tt]est[Cc]ase return BeginTestCase;
1220 [Ee]nd[Tt]est[Cc]ase return EndTestCase;
1223 <SC_MAIN_CONTROLLER>
1225 [Ll]ocal[Aa]ddress return LocalAddress;
1226 [Tt][Cc][Pp][Pp]ort return TCPPort;
1227 [Kk]ill[Tt]imer return KillTimer;
1228 [Nn]um[Hh][Cc]s return NumHCs;
1229 [Uu]nix[Ss]ockets[Ee]nabled return UnixSocketEnabled;
1230 [Yy][Ee][Ss] return YesToken;
1231 [Nn][Oo] return NoToken;
1235 yylval.str_val = mcopystr(yytext);
1239 <SC_MODULE_PARAMETERS>{ASN1LOWERIDENTIFIER} {
1240 yylval.str_val = mcopystr(yytext);
1241 for (size_t i = 0; i < yyleng; i++) {
1242 if (yylval.str_val[i] == '-') yylval.str_val[i] = '_';
1244 TTCN_warning("In line %d of configuration file: `%s' is not a valid TTCN-3 "
1245 "identifier. Did you mean `%s'?", current_line, yytext, yylval.str_val);
1246 return ASN1LowerIdentifier;
1249 <SC_GROUPS,SC_COMPONENTS,SC_MAIN_CONTROLLER>{DNSNAME}|{IPV6} return DNSName;
1250 /* Information is discarded ! */
1252 <SC_STRING2TTCN_COMPONENT>{COMPONENT} {
1253 /* Ignore the component name, just return its number */
1254 size_t len = strlen(yytext);
1255 size_t pos = len - 1;
1256 while(yytext[pos] != '(' && pos != 0) {
1259 char* comp_num_str = mcopystrn(yytext + pos + 1, len - pos - 1);
1260 yylval.int_val = new int_val_t(comp_num_str);
1266 if (config_defines != NULL) {
1267 char *macroname = get_macro_id_from_ref(yytext);
1269 const char *macrovalue =
1270 string_map_get_bykey(config_defines, macroname, ¯olen);
1271 if (macrovalue != NULL) {
1272 if (!strcmp(macrovalue, "true")) yylval.bool_val = TRUE;
1273 else if (!strcmp(macrovalue, "false")) yylval.bool_val = FALSE;
1275 config_process_error_f("Macro `%s' cannot be interpreted as boolean "
1276 "value: `%s'", macroname, macrovalue);
1277 yylval.bool_val = FALSE;
1280 config_process_error_f("No macro or environmental variable defined"
1281 " with name `%s'", macroname);
1282 yylval.bool_val = FALSE;
1286 config_process_error("Internal error: Macro reference cannot be used in "
1288 yylval.bool_val = FALSE;
1290 return BooleanValue;
1294 if (config_defines != NULL) {
1295 char *macroname = get_macro_id_from_ref(yytext);
1297 const char *macrovalue =
1298 string_map_get_bykey(config_defines, macroname, ¯olen);
1299 if (macrovalue != NULL) {
1300 if (string_is_int(macrovalue, macrolen))
1301 yylval.int_val = new int_val_t(macrovalue);
1303 config_process_error_f("Macro `%s' cannot be interpreted as integer "
1304 "value: `%s'", macroname, macrovalue);
1305 yylval.int_val = new int_val_t((RInt)0);
1308 config_process_error_f("No macro or environmental variable defined"
1309 " with name `%s'", macroname);
1310 yylval.int_val = new int_val_t((RInt)0);
1314 config_process_error("Internal error: Macro reference cannot be used in "
1316 yylval.int_val = new int_val_t((RInt)0);
1318 if (YY_START == SC_MODULE_PARAMETERS || YY_START == SC_CHAR_KEYWORD) {
1319 // return a different token for module parameters so it doesn't conflict with references
1326 if (config_defines != NULL) {
1327 char *macroname = get_macro_id_from_ref(yytext);
1329 const char *macrovalue =
1330 string_map_get_bykey(config_defines, macroname, ¯olen);
1331 if (macrovalue != NULL) {
1332 if (string_is_float(macrovalue, macrolen))
1333 yylval.float_val = atof(macrovalue);
1335 config_process_error_f("Macro `%s' cannot be interpreted as float value: "
1336 "`%s'", macroname, macrovalue);
1337 yylval.float_val = 0.0;
1340 config_process_error_f("No macro or environmental variable defined"
1341 " with name `%s'", macroname);
1342 yylval.float_val = 0.0;
1346 config_process_error("Internal error: Macro reference cannot be used in "
1348 yylval.float_val = 0.0;
1350 if (YY_START == SC_MODULE_PARAMETERS || YY_START == SC_CHAR_KEYWORD) {
1351 // return a different token for module parameters so it doesn't conflict with references
1358 if (config_defines != NULL) {
1359 char *macroname = get_macro_id_from_ref(yytext);
1361 const char *macrovalue =
1362 string_map_get_bykey(config_defines, macroname, ¯olen);
1363 boolean is_asn = FALSE;
1364 if (macrovalue != NULL) {
1365 if (string_is_id(macrovalue, macrolen)) {
1366 yylval.str_val = mcopystr(macrovalue);
1367 for (size_t i = 0; i < macrolen; i++) {
1368 if (yylval.str_val[i]=='-') {
1369 yylval.str_val[i] = '_';
1374 TTCN_warning("In line %d of configuration file: `%s' is not a valid"
1375 " TTCN-3 identifier. Did you mean `%s'?",
1376 current_line, macrovalue, yylval.str_val);
1378 config_process_error_f("Macro `%s' cannot be interpreted as identifier: "
1379 "`%s'", macroname, macrovalue);
1380 yylval.str_val = memptystr();
1383 config_process_error_f("No macro or environmental variable defined with "
1384 "name `%s'", macroname);
1385 yylval.str_val = memptystr();
1388 return is_asn ? ASN1LowerIdentifier : Identifier;
1390 config_process_error("Internal error: Macro reference cannot be used in "
1392 yylval.str_val = memptystr();
1398 if (config_defines == NULL) {
1399 config_process_error("Internal error: Macro reference cannot be used in "
1401 yylval.charstring_val.n_chars = 0;
1402 yylval.charstring_val.chars_ptr = memptystr();
1403 if (YY_START == SC_MODULE_PARAMETERS || YY_START == SC_CHAR_KEYWORD) {
1404 // return a different token for module parameters so it doesn't conflict with references
1411 if (yytext[1] == '{') macroname = get_macro_id_from_ref(yytext);
1412 else macroname = mcopystr(yytext + 1);
1414 const char *macrovalue = string_map_get_bykey
1415 (config_defines, macroname, ¯olen);
1417 if (macrovalue == NULL) {
1418 config_process_error_f("No macro or environmental variable defined with name "
1420 yylval.charstring_val.n_chars=0;
1421 yylval.charstring_val.chars_ptr=memptystr();
1423 if (YY_START == SC_MODULE_PARAMETERS || YY_START == SC_CHAR_KEYWORD) {
1424 // return a different token for module parameters so it doesn't conflict with references
1430 if (macrolen > 0 && macrovalue[0] == '{') { // structured
1431 main_buffer = YY_CURRENT_BUFFER;
1432 expansion_buffer = yy_scan_string(macrovalue);
1433 yy_switch_to_buffer(expansion_buffer);
1436 yylval.charstring_val.n_chars=macrolen;
1437 yylval.charstring_val.chars_ptr=(char*)Malloc(macrolen+1);
1438 memcpy(yylval.charstring_val.chars_ptr, macrovalue, macrolen+1);
1440 if (YY_START == SC_MODULE_PARAMETERS || YY_START == SC_CHAR_KEYWORD) {
1441 // return a different token for module parameters so it doesn't conflict with references
1449 if (config_defines != NULL) {
1450 char *macroname = get_macro_id_from_ref(yytext);
1452 const char *macrovalue =
1453 string_map_get_bykey(config_defines, macroname, ¯olen);
1454 if (macrovalue != NULL) {
1455 if (string_is_bstr(macrovalue, macrolen)) {
1456 yylval.bitstring_val.n_bits = macrolen;
1457 int n_bytes = (yylval.bitstring_val.n_bits + 7) / 8;
1458 yylval.bitstring_val.bits_ptr = (unsigned char *)Malloc(n_bytes);
1459 memset(yylval.bitstring_val.bits_ptr, 0, n_bytes);
1460 for (int i = 0; i < yylval.bitstring_val.n_bits; i++)
1461 if (macrovalue[i] == '1')
1462 yylval.bitstring_val.bits_ptr[i/8] |= 1 << (i % 8);
1464 config_process_error_f("Macro `%s' cannot be interpreted as bitstring "
1465 "value: `%s'", macroname, macrovalue);
1466 yylval.bitstring_val.n_bits = 0;
1467 yylval.bitstring_val.bits_ptr = NULL;
1470 config_process_error_f("No macro or environmental variable defined with "
1471 "name `%s'", macroname);
1472 yylval.bitstring_val.n_bits = 0;
1473 yylval.bitstring_val.bits_ptr = NULL;
1477 config_process_error_f("Internal error: Macro reference cannot be used in "
1479 yylval.bitstring_val.n_bits = 0;
1480 yylval.bitstring_val.bits_ptr = NULL;
1486 if (config_defines != NULL) {
1487 char *macroname = get_macro_id_from_ref(yytext);
1489 const char *macrovalue =
1490 string_map_get_bykey(config_defines, macroname, ¯olen);
1491 if (macrovalue != NULL) {
1492 if(string_is_hstr(macrovalue, macrolen)) {
1493 yylval.hexstring_val.n_nibbles = macrolen;
1494 int n_bytes = (yylval.hexstring_val.n_nibbles + 1) / 2;
1495 yylval.hexstring_val.nibbles_ptr = (unsigned char *)Malloc(n_bytes);
1496 memset(yylval.hexstring_val.nibbles_ptr, 0, n_bytes);
1497 for (int i = 0; i < yylval.hexstring_val.n_nibbles; i++) {
1498 unsigned int hex_digit;
1499 sscanf(macrovalue+i, "%1x", &hex_digit);
1500 if(i % 2) yylval.hexstring_val.nibbles_ptr[i/2] |=
1502 else yylval.hexstring_val.nibbles_ptr[i/2] |= hex_digit;
1505 config_process_error_f("Macro `%s' cannot be interpreted as hexstring "
1506 "value: `%s'", macroname, macrovalue);
1507 yylval.hexstring_val.n_nibbles = 0;
1508 yylval.hexstring_val.nibbles_ptr = NULL;
1511 config_process_error_f("No macro or environmental variable defined with "
1512 "name `%s'", macroname);
1513 yylval.hexstring_val.n_nibbles = 0;
1514 yylval.hexstring_val.nibbles_ptr = NULL;
1518 config_process_error("Internal error: Macro reference cannot be used in "
1520 yylval.hexstring_val.n_nibbles = 0;
1521 yylval.hexstring_val.nibbles_ptr = NULL;
1527 if (config_defines != NULL) {
1528 char *macroname = get_macro_id_from_ref(yytext);
1530 const char *macrovalue =
1531 string_map_get_bykey(config_defines, macroname, ¯olen);
1532 if (macrovalue != NULL) {
1533 if (string_is_ostr(macrovalue, macrolen)) {
1534 yylval.octetstring_val.n_octets = macrolen / 2;
1535 yylval.octetstring_val.octets_ptr = (unsigned char *)
1536 Malloc(yylval.octetstring_val.n_octets);
1537 for (int i = 0; i < yylval.octetstring_val.n_octets; i++) {
1538 unsigned int this_octet;
1539 sscanf(macrovalue+2*i, "%2x", &this_octet);
1540 yylval.octetstring_val.octets_ptr[i] = this_octet;
1543 config_process_error_f("Macro `%s' cannot be interpreted as octetstring "
1544 "value: `%s'", macroname, macrovalue);
1545 yylval.octetstring_val.n_octets = 0;
1546 yylval.octetstring_val.octets_ptr = NULL;
1549 config_process_error_f("No macro or environmental variable defined with "
1550 "name `%s'", macroname);
1551 yylval.octetstring_val.n_octets = 0;
1552 yylval.octetstring_val.octets_ptr = NULL;
1556 config_process_error_f("Internal error: Macro reference cannot be used in "
1558 yylval.octetstring_val.n_octets = 0;
1559 yylval.octetstring_val.octets_ptr = NULL;
1565 if (config_defines != NULL) {
1566 char *macroname = get_macro_id_from_ref(yytext);
1568 const char *macrovalue =
1569 string_map_get_bykey(config_defines, macroname, ¯olen);
1570 if (macrovalue != NULL) {
1571 yylval.octetstring_val.n_octets=macrolen;
1572 yylval.octetstring_val.octets_ptr = (unsigned char*)Malloc(macrolen);
1573 memcpy(yylval.octetstring_val.octets_ptr, macrovalue, macrolen);
1576 config_process_error_f("No macro or environmental variable defined with "
1577 "name `%s'", macroname);
1578 yylval.octetstring_val.n_octets = 0;
1579 yylval.octetstring_val.octets_ptr = NULL;
1583 config_process_error("Internal error: Macro reference cannot be used in "
1585 yylval.octetstring_val.n_octets = 0;
1586 yylval.octetstring_val.octets_ptr = NULL;
1592 if (config_defines != NULL) {
1593 char *macroname = get_macro_id_from_ref(yytext);
1595 const char *macrovalue =
1596 string_map_get_bykey(config_defines, macroname, ¯olen);
1597 if (macrovalue != NULL) {
1598 if (!string_is_hostname(macrovalue, macrolen)) {
1599 config_process_error_f("Macro `%s' cannot be interpreted as host name: "
1600 "`%s'", macroname, macrovalue);
1603 config_process_error_f("No macro or environmental variable defined with "
1604 "name `%s'", macroname);
1608 config_process_error("Internal error: Macro reference cannot be used in "
1614 ":="|"=" return AssignmentChar;
1615 "&=" return ConcatChar;
1618 if (expansion_buffer) {
1619 yy_switch_to_buffer(main_buffer);
1620 yy_delete_buffer(expansion_buffer);
1621 expansion_buffer = NULL;
1623 if (include_chain->size() > 1) {
1624 yy_delete_buffer(YY_CURRENT_BUFFER);
1625 fclose(include_chain->back().fp);
1626 include_chain->pop_back();
1627 yy_switch_to_buffer(include_chain->back().buffer_state);
1628 current_line = include_chain->back().line_number;
1629 BEGIN(SC_ORDERED_INCLUDE);
1644 void reset_config_process_lex(const char* fname)
1646 if (!include_chain) {
1647 include_chain = new std::deque<IncludeElem<YY_BUFFER_STATE> >();
1652 include_chain->push_back(IncludeElem<YY_BUFFER_STATE>(std::string(fname), config_process_in));
1656 void config_process_close() {
1657 delete include_chain;
1658 include_chain = NULL;
1661 int config_process_get_current_line()
1663 return current_line;