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 ******************************************************************************/
9 %option never-interactive
21 #include "../common/cfg_process_utils.hh"
22 #include "../common/Path2.hh"
24 #include "../common/memory.h"
26 #include "Parameters.h"
27 #include "Param_Types.hh"
29 #include "LoggingBits.hh"
30 #include "LoggingParam.hh"
32 #include "config_process.tab.hh"
33 #include "../common/config_preproc.h"
34 #include "../common/path.h"
36 #include "../common/dbgnew.hh"
38 extern string_map_t *config_defines;
40 #define yylval config_process_lval
42 static int current_line;
44 static YY_BUFFER_STATE main_buffer = NULL;
45 /* This buffer is used for macro expansion */
46 static YY_BUFFER_STATE expansion_buffer = NULL;
48 static std::deque<IncludeElem<YY_BUFFER_STATE> >* include_chain = NULL;
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);
57 std::string get_cfg_process_current_file() {
58 if (include_chain && !include_chain->empty()) {
59 return include_chain->back().get_full_path();
70 LINECOMMENT ("//"|"#")[^\r\n]*{NEWLINE}
72 NUMBER 0|([1-9][0-9]*)
74 FLOAT [+-]?({NUMBER}\.[0-9]+)|((({NUMBER}(\.[0-9]+)?)|(\.[0-9]+))[Ee][+-]?{NUMBER})
79 BITSTRINGMATCH '{BINMATCH}*'B
80 BITSTRING_BAD '[^']*'B
84 HEXMATCH [0-9A-Fa-f\?\*]
85 HEXSTRINGMATCH '{HEXMATCH}*'H
86 HEXSTRING_BAD '[^']*'H
90 OCTMATCH {HEX}{HEX}|\?|\*
91 OCTETSTRINGMATCH '{OCTMATCH}*'O
92 OCTETSTRING_BAD '[^']*'O
96 TTCN3IDENTIFIER [A-Za-z][A-Za-z0-9_]*
97 ASN1LOWERIDENTIFIER [a-z](-?[A-Za-z0-9]+)*
99 COMPONENT .*\({NUMBER}\)
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}"}"
112 HOSTNAME [A-Za-z0-9]([A-Za-z0-9_\-]*[A-Za-z0-9])?
113 DNSNAME {HOSTNAME}(\.{HOSTNAME})*\.?
115 /* Example: fe80::c002:37ff:fe6c:0%fastethernet0/0 */
116 IPV6 [0-9A-Fa-f:.]+(%[0-9A-Za-z]+)?
118 TTCNSTRINGPARSING "$#&&&(#TTCNSTRINGPARSING$#&&^#% "
119 TTCNSTRINGPARSING_COMPONENT "$#&&&(#TTCNSTRINGPARSING_COMPONENT$#&&^#% "
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 SC_PROFILER
128 int caller_state = INITIAL;
130 int cstring_start = -1;
132 /* Eat up comments and whitespaces */
135 caller_state = YY_START;
136 BEGIN(SC_commentblock);
140 "*/" BEGIN(caller_state);
141 {NEWLINE} current_line++;
144 config_process_error("Unterminated block comment (missing */ at the "
152 {LINECOMMENT} current_line++;
154 {TTCNSTRINGPARSING} {
155 if (Ttcn_String_Parsing::happening()) {
156 BEGIN(SC_MODULE_PARAMETERS);
157 return TtcnStringParsingKeyword;
159 config_process_error("Invalid character sequence encountered.");
163 {TTCNSTRINGPARSING_COMPONENT} {
164 if (Ttcn_String_Parsing::happening()) {
165 BEGIN(SC_STRING2TTCN_COMPONENT);
166 return TtcnStringParsingKeyword;
168 config_process_error("Invalid character sequence encountered.");
172 /* Section delimiters */
174 <*>"["{WS}MODULE_PARAMETERS{WS}"]" {
175 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
176 BEGIN(SC_MODULE_PARAMETERS);
177 return ModuleParametersKeyword;
181 <*>"["{WS}LOGGING{WS}"]" {
182 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
184 return LoggingKeyword;
188 <*>"["{WS}PROFILER{WS}"]" {
189 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
191 return ProfilerKeyword;
195 <*>"["{WS}TESTPORT_PARAMETERS{WS}"]" {
196 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
197 BEGIN(SC_TESTPORT_PARAMETERS);
198 return TestportParametersKeyword;
202 <*>"["{WS}EXECUTE{WS}"]" {
203 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
205 return ExecuteKeyword;
209 <*>"["{WS}EXTERNAL_COMMANDS{WS}"]" {
210 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
211 BEGIN(SC_EXTERNAL_COMMANDS);
212 return ExternalCommandsKeyword;
216 <*>"["{WS}GROUPS{WS}"]" {
217 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
219 return GroupsKeyword;
223 <*>"["{WS}COMPONENTS{WS}"]" {
224 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
225 BEGIN(SC_COMPONENTS);
226 return ComponentsKeyword;
230 <*>"["{WS}MAIN_CONTROLLER{WS}"]" {
231 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
232 BEGIN(SC_MAIN_CONTROLLER);
233 return MainControllerKeyword;
237 <*>"["{WS}INCLUDE{WS}"]" {
238 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
240 return IncludeKeyword;
244 <*>"["{WS}ORDERED_INCLUDE{WS}"]" {
245 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
246 BEGIN(SC_ORDERED_INCLUDE);
250 <*>"["{WS}DEFINE{WS}"]" {
251 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
253 return DefineKeyword;
257 /* Rules for SC_DEFINE must precede everything else */
262 caller_state = SC_DEFINE;
263 BEGIN(SC_commentblock);
267 caller_state = SC_DEFINE;
270 cstring_start = current_line;
273 {LINECOMMENT}|{NEWLINE} current_line++;
277 . /* eat unnecessary chars */
284 yylval.int_val = new int_val_t(yytext);
289 yylval.float_val = atof(yytext);
294 yylval.bitstring_val.n_bits = yyleng - 3;
295 int n_bytes = (yylval.bitstring_val.n_bits + 7) / 8;
296 yylval.bitstring_val.bits_ptr = (unsigned char *)Malloc(n_bytes);
297 memset(yylval.bitstring_val.bits_ptr, 0, n_bytes);
298 for (int i = 0; i < yylval.bitstring_val.n_bits; i++)
299 if (yytext[i+1] == '1')
300 yylval.bitstring_val.bits_ptr[i/8] |= 1 << (i % 8);
305 yylval.str_val = mcopystrn(yytext+1, yyleng-3);
310 config_process_error("Invalid bitstring value.");
311 yylval.bitstring_val.n_bits = 0;
312 yylval.bitstring_val.bits_ptr = NULL;
317 yylval.hexstring_val.n_nibbles = yyleng - 3;
318 int n_bytes = (yylval.hexstring_val.n_nibbles + 1) / 2;
319 yylval.hexstring_val.nibbles_ptr = (unsigned char *)Malloc(n_bytes);
320 memset(yylval.hexstring_val.nibbles_ptr, 0, n_bytes);
321 for (int i = 0; i < yylval.hexstring_val.n_nibbles; i++) {
322 unsigned int hex_digit;
323 sscanf(yytext+i+1, "%1x", &hex_digit);
324 if(i % 2) yylval.hexstring_val.nibbles_ptr[i/2] |=
326 else yylval.hexstring_val.nibbles_ptr[i/2] |= hex_digit;
332 yylval.str_val = mcopystrn(yytext+1, yyleng-3);
337 config_process_error("Invalid hexstring value.");
338 yylval.hexstring_val.n_nibbles = 0;
339 yylval.hexstring_val.nibbles_ptr = NULL;
344 yylval.octetstring_val.n_octets = (yyleng - 3) / 2;
345 yylval.octetstring_val.octets_ptr = (unsigned char *)
346 Malloc(yylval.octetstring_val.n_octets);
348 for (int i = 0; i < yylval.octetstring_val.n_octets; i++) {
349 unsigned int this_octet;
350 sscanf(yytext+2*i+1, "%2x", &this_octet);
351 yylval.octetstring_val.octets_ptr[i] = this_octet;
357 yylval.str_val = mcopystrn(yytext+1, yyleng-3);
362 config_process_error("Invalid octetstring value.");
363 yylval.octetstring_val.n_octets = 0;
364 yylval.octetstring_val.octets_ptr = NULL;
368 {BINSTRING_BAD} config_process_error("Invalid string value.");
370 ' config_process_error("Unmatched ' character.");
373 caller_state = YY_START;
376 cstring_start = current_line;
383 /* end of the string */
385 switch (caller_state) {
389 case SC_ORDERED_INCLUDE:
391 std::string error_msg = switch_lexer(include_chain, cstring,
392 YY_CURRENT_BUFFER, yy_create_buffer, yy_switch_to_buffer,
393 current_line, YY_BUF_SIZE);
394 if (error_msg.empty()) {
397 config_process_error(error_msg.c_str());
402 set_ret_val_cstr(cstring);
409 \\[\\'"?] cstring += yytext[1]; /* backslash-quoted \ or " or ' or ? */
410 \\{NEWLINE} current_line++;
420 sscanf(yytext + 1, "%o", &c);
422 config_process_error("Invalid octal character code in string "
424 else if (c == 0 && caller_state != SC_MODULE_PARAMETERS)
425 config_process_error("NUL characters in string literals are "
426 "allowed only in section [MODULE_PARAMETERS].");
431 sscanf(yytext + 2, "%x", &c);
432 if (c == 0 && caller_state != SC_MODULE_PARAMETERS)
433 config_process_error("NUL characters in string literals are "
434 "allowed only in section [MODULE_PARAMETERS].");
438 config_process_error("Invalid escape sequence in string literal.");
441 cstring.append(yytext, yyleng);
444 . cstring += yytext[0];
446 if (cstring_start >=0) {
447 config_process_error_f("Unterminated string literal starting at line %d "
448 "(missing \" at the end of file).", cstring_start);
450 config_process_error("Unterminated string literal (missing \" at the "
454 if (caller_state!=SC_DEFINE) {
455 set_ret_val_cstr(cstring);
463 /* Section-wide keywords */
465 <SC_MODULE_PARAMETERS>
467 NULL return NULLKeyword;
468 null return nullKeyword;
469 char return CharKeyword;
470 objid return ObjIdKeyword;
471 omit return OmitKeyword;
473 yylval.verdict_val = NONE;
477 yylval.verdict_val = PASS;
481 yylval.verdict_val = INCONC;
485 yylval.verdict_val = FAIL;
489 yylval.verdict_val = ERROR;
492 complement return ComplementKeyword;
493 "\.\." return DotDot;
494 superset return SupersetKeyword;
495 subset return SubsetKeyword;
496 pattern return PatternKeyword;
497 permutation return PermutationKeyword;
498 length return LengthKeyword;
499 ifpresent return IfpresentKeyword;
500 infinity return InfinityKeyword;
503 <SC_MODULE_PARAMETERS,SC_LOGGING,SC_PROFILER>
506 yylval.bool_val = TRUE;
510 yylval.bool_val = FALSE;
515 /* We could add SC_LOGGING to make mtc and system special for the logging section too */
516 <SC_MODULE_PARAMETERS,SC_STRING2TTCN_COMPONENT,SC_TESTPORT_PARAMETERS,SC_LOGGING>
518 mtc return MTCKeyword;
519 system return SystemKeyword;
525 [Ll]og[Ff]ile return LogFile;
527 [Ee]mergency[Ll]ogging return EmergencyLogging;
529 [Ee]mergency[Ll]ogging[Bb]ehaviour return EmergencyLoggingBehaviour;
531 [Ee]mergency[Ll]ogging[Mm]ask return EmergencyLoggingMask;
533 [Ff]ile[Mm]ask return FileMask;
535 [Cc]onsole[Mm]ask return ConsoleMask;
537 [Tt]ime[Ss]tamp[Ff]ormat return TimestampFormat;
538 [Cc]onsole[Tt]ime[Ss]tamp[Ff]ormat return ConsoleTimestampFormat;
540 [Ll]og[Ss]ource[Ii]nfo |
541 [Ss]ource[Ii]nfo[Ff]ormat return SourceInfoFormat;
543 [Aa]ppend[Ff]ile return AppendFile;
545 [Ll]og[Ee]vent[Tt]ypes return LogEventTypes;
547 [Ll]og[Ee]ntity[Nn]ame return LogEntityName;
549 [Ll]og[Ff]ile[Ss]ize return LogFileSize;
551 [Ll]og[Ff]ile[Nn]umber return LogFileNumber;
553 [Dd]isk[Ff]ull[Aa]ction return DiskFullAction;
555 [Mm]atching[Hh]ints return MatchingHints;
557 [Ll]ogger[Pp]lugins return LoggerPlugins;
559 /* Lexer's handling of logging keywords:
561 * For sub-categories and categories with only one member,
562 * LoggingBit is returned and the value is the corresponding
563 * TTCN_Logger::Severity.
565 * For the old categories which now have subcategories, the old keyword
566 * is returned as LoggingBitCollection with the corresponding
567 * _UNQUALIFIED as the semantic value. The parser will construct the
570 * The lexer never returns a token with a Logging_Bits type.
573 yylval.logseverity_val = TTCN_Logger::NOTHING_TO_LOG;
578 yylval.logseverity_val = TTCN_Logger::ACTION_UNQUALIFIED;
582 yylval.logseverity_val = TTCN_Logger::ACTION_UNQUALIFIED;
583 return LoggingBitCollection;
587 yylval.logseverity_val = TTCN_Logger::DEBUG_ENCDEC;
591 yylval.logseverity_val = TTCN_Logger::DEBUG_TESTPORT;
595 yylval.logseverity_val = TTCN_Logger::DEBUG_UNQUALIFIED;
599 yylval.logseverity_val = TTCN_Logger::DEBUG_UNQUALIFIED;
600 return LoggingBitCollection;
604 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_ACTIVATE;
607 DEFAULTOP_DEACTIVATE {
608 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_DEACTIVATE;
612 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_EXIT;
615 DEFAULTOP_UNQUALIFIED {
616 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_UNQUALIFIED;
620 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_UNQUALIFIED;
621 return LoggingBitCollection;
625 yylval.logseverity_val = TTCN_Logger::ERROR_UNQUALIFIED;
629 yylval.logseverity_val = TTCN_Logger::ERROR_UNQUALIFIED;
630 return LoggingBitCollection;
634 yylval.logseverity_val = TTCN_Logger::EXECUTOR_COMPONENT;
637 EXECUTOR_CONFIGDATA {
638 yylval.logseverity_val = TTCN_Logger::EXECUTOR_CONFIGDATA;
641 EXECUTOR_EXTCOMMAND {
642 yylval.logseverity_val = TTCN_Logger::EXECUTOR_EXTCOMMAND;
645 EXECUTOR_LOGOPTIONS {
646 yylval.logseverity_val = TTCN_Logger::EXECUTOR_LOGOPTIONS;
650 yylval.logseverity_val = TTCN_Logger::EXECUTOR_RUNTIME;
653 EXECUTOR_UNQUALIFIED {
654 yylval.logseverity_val = TTCN_Logger::EXECUTOR_UNQUALIFIED;
658 yylval.logseverity_val = TTCN_Logger::EXECUTOR_UNQUALIFIED;
659 return LoggingBitCollection;
663 yylval.logseverity_val = TTCN_Logger::FUNCTION_RND;
666 FUNCTION_UNQUALIFIED {
667 yylval.logseverity_val = TTCN_Logger::FUNCTION_UNQUALIFIED;
671 yylval.logseverity_val = TTCN_Logger::FUNCTION_UNQUALIFIED;
672 return LoggingBitCollection;
676 yylval.logseverity_val = TTCN_Logger::MATCHING_DONE;
680 yylval.logseverity_val = TTCN_Logger::MATCHING_MCSUCCESS;
684 yylval.logseverity_val = TTCN_Logger::MATCHING_MCUNSUCC;
688 yylval.logseverity_val = TTCN_Logger::MATCHING_MMSUCCESS;
692 yylval.logseverity_val = TTCN_Logger::MATCHING_MMUNSUCC;
696 yylval.logseverity_val = TTCN_Logger::MATCHING_PCSUCCESS;
700 yylval.logseverity_val = TTCN_Logger::MATCHING_PCUNSUCC;
704 yylval.logseverity_val = TTCN_Logger::MATCHING_PMSUCCESS;
708 yylval.logseverity_val = TTCN_Logger::MATCHING_PMUNSUCC;
712 yylval.logseverity_val = TTCN_Logger::MATCHING_PROBLEM;
716 yylval.logseverity_val = TTCN_Logger::MATCHING_TIMEOUT;
719 MATCHING_UNQUALIFIED {
720 yylval.logseverity_val = TTCN_Logger::MATCHING_UNQUALIFIED;
724 yylval.logseverity_val = TTCN_Logger::MATCHING_UNQUALIFIED;
725 return LoggingBitCollection;
729 yylval.logseverity_val = TTCN_Logger::PARALLEL_PORTCONN;
733 yylval.logseverity_val = TTCN_Logger::PARALLEL_PORTMAP;
737 yylval.logseverity_val = TTCN_Logger::PARALLEL_PTC;
740 PARALLEL_UNQUALIFIED {
741 yylval.logseverity_val = TTCN_Logger::PARALLEL_UNQUALIFIED;
745 yylval.logseverity_val = TTCN_Logger::PARALLEL_UNQUALIFIED;
746 return LoggingBitCollection;
750 yylval.logseverity_val = TTCN_Logger::PORTEVENT_DUALRECV;
754 yylval.logseverity_val = TTCN_Logger::PORTEVENT_DUALSEND;
758 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MCRECV;
762 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MCSEND;
766 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MMRECV;
770 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MMSEND;
774 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MQUEUE;
778 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PCIN;
782 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PCOUT;
786 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PMIN;
790 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PMOUT;
794 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PQUEUE;
798 yylval.logseverity_val = TTCN_Logger::PORTEVENT_STATE;
801 PORTEVENT_UNQUALIFIED {
802 yylval.logseverity_val = TTCN_Logger::PORTEVENT_UNQUALIFIED;
806 yylval.logseverity_val = TTCN_Logger::PORTEVENT_UNQUALIFIED;
807 return LoggingBitCollection;
810 STATISTICS_UNQUALIFIED {
811 yylval.logseverity_val = TTCN_Logger::STATISTICS_UNQUALIFIED;
815 yylval.logseverity_val = TTCN_Logger::STATISTICS_VERDICT;
819 yylval.logseverity_val = TTCN_Logger::STATISTICS_UNQUALIFIED;
820 return LoggingBitCollection;
824 yylval.logseverity_val = TTCN_Logger::TESTCASE_FINISH;
828 yylval.logseverity_val = TTCN_Logger::TESTCASE_START;
831 TESTCASE_UNQUALIFIED {
832 yylval.logseverity_val = TTCN_Logger::TESTCASE_UNQUALIFIED;
836 yylval.logseverity_val = TTCN_Logger::TESTCASE_UNQUALIFIED;
837 return LoggingBitCollection;
841 yylval.logseverity_val = TTCN_Logger::TIMEROP_GUARD;
845 yylval.logseverity_val = TTCN_Logger::TIMEROP_READ;
849 yylval.logseverity_val = TTCN_Logger::TIMEROP_START;
853 yylval.logseverity_val = TTCN_Logger::TIMEROP_STOP;
857 yylval.logseverity_val = TTCN_Logger::TIMEROP_TIMEOUT;
860 TIMEROP_UNQUALIFIED {
861 yylval.logseverity_val = TTCN_Logger::TIMEROP_UNQUALIFIED;
865 yylval.logseverity_val = TTCN_Logger::TIMEROP_UNQUALIFIED;
866 return LoggingBitCollection;
870 yylval.logseverity_val = TTCN_Logger::USER_UNQUALIFIED;
874 yylval.logseverity_val = TTCN_Logger::USER_UNQUALIFIED;
875 return LoggingBitCollection;
879 yylval.logseverity_val = TTCN_Logger::VERDICTOP_FINAL;
882 VERDICTOP_GETVERDICT {
883 yylval.logseverity_val = TTCN_Logger::VERDICTOP_GETVERDICT;
886 VERDICTOP_SETVERDICT {
887 yylval.logseverity_val = TTCN_Logger::VERDICTOP_SETVERDICT;
890 VERDICTOP_UNQUALIFIED {
891 yylval.logseverity_val = TTCN_Logger::VERDICTOP_UNQUALIFIED;
895 yylval.logseverity_val = TTCN_Logger::VERDICTOP_UNQUALIFIED;
896 return LoggingBitCollection;
899 WARNING_UNQUALIFIED {
900 yylval.logseverity_val = TTCN_Logger::WARNING_UNQUALIFIED;
904 yylval.logseverity_val = TTCN_Logger::WARNING_UNQUALIFIED;
905 return LoggingBitCollection;
909 yylval.logseverity_val = TTCN_Logger::LOG_ALL_IMPORTANT;
910 return LoggingBitCollection;
914 yylval.timestamp_value = TTCN_Logger::TIMESTAMP_TIME;
915 return TimestampValue;
917 [Dd][Aa][Tt][Ee][Tt][Ii][Mm][Ee] {
918 yylval.timestamp_value = TTCN_Logger::TIMESTAMP_DATETIME;
919 return TimestampValue;
921 [Ss][Ee][Cc][Oo][Nn][Dd][Ss] {
922 yylval.timestamp_value = TTCN_Logger::TIMESTAMP_SECONDS;
923 return TimestampValue;
926 yylval.source_info_value = TTCN_Logger::SINFO_NONE;
927 return SourceInfoValue;
929 [Ss][Ii][Nn][Gg][Ll][Ee] {
930 yylval.source_info_value = TTCN_Logger::SINFO_SINGLE;
931 return SourceInfoValue;
933 [Ss][Tt][Aa][Cc][Kk] {
934 yylval.source_info_value = TTCN_Logger::SINFO_STACK;
935 return SourceInfoValue;
938 yylval.bool_val = TRUE;
942 yylval.bool_val = FALSE;
946 yylval.emergency_logging_behaviour_value = TTCN_Logger::BUFFER_ALL;
947 return EmergencyLoggingBehaviourValue;
950 yylval.emergency_logging_behaviour_value = TTCN_Logger::BUFFER_MASKED;
951 return EmergencyLoggingBehaviourValue;
954 [Cc]ompact return Compact;
955 [Dd]etailed return Detailed;
956 [Ss]ub[Cc]ategories return SubCategories;
958 [Ee]rror return Error;
962 [Rr]etry return Retry;
964 [Dd]elete return Delete;
969 [Dd]isable[Pp]rofiler return DisableProfilerKeyword;
970 [Dd]isable[Cc]overage return DisableCoverageKeyword;
971 [Dd]ata[Bb]ase[Ff]ile return DatabaseFileKeyword;
972 [Aa]ggregate[Dd]ata return AggregateDataKeyword;
973 [Ss]tatistics[Ff]ile return StatisticsFileKeyword;
974 [Dd]isable[Ss]tatistics return DisableStatisticsKeyword;
977 <SC_EXECUTE>control return ControlKeyword;
979 <SC_EXTERNAL_COMMANDS>
981 [Bb]egin[Cc]ontrol[Pp]art return BeginControlPart;
982 [Ee]nd[Cc]ontrol[Pp]art return EndControlPart;
983 [Bb]egin[Tt]est[Cc]ase return BeginTestCase;
984 [Ee]nd[Tt]est[Cc]ase return EndTestCase;
989 [Ll]ocal[Aa]ddress return LocalAddress;
990 [Tt][Cc][Pp][Pp]ort return TCPPort;
991 [Kk]ill[Tt]imer return KillTimer;
992 [Nn]um[Hh][Cc]s return NumHCs;
993 [Uu]nix[Ss]ockets[Ee]nabled return UnixSocketEnabled;
994 [Yy][Ee][Ss] return YesToken;
995 [Nn][Oo] return NoToken;
999 yylval.str_val = mcopystr(yytext);
1003 <SC_MODULE_PARAMETERS>{ASN1LOWERIDENTIFIER} {
1004 yylval.str_val = mcopystr(yytext);
1005 for (int i = 0; i < yyleng; i++) {
1006 if (yylval.str_val[i] == '-') yylval.str_val[i] = '_';
1008 TTCN_warning("In line %d of configuration file: `%s' is not a valid TTCN-3 "
1009 "identifier. Did you mean `%s'?", current_line, yytext, yylval.str_val);
1010 return ASN1LowerIdentifier;
1013 <SC_GROUPS,SC_COMPONENTS,SC_MAIN_CONTROLLER>{DNSNAME}|{IPV6} return DNSName;
1014 /* Information is discarded ! */
1016 <SC_STRING2TTCN_COMPONENT>{COMPONENT} {
1017 /* Ignore the component name, just return its number */
1018 size_t len = strlen(yytext);
1019 size_t pos = len - 1;
1020 while(yytext[pos] != '(' && pos != 0) {
1023 char* comp_num_str = mcopystrn(yytext + pos + 1, len - pos - 1);
1024 yylval.int_val = new int_val_t(comp_num_str);
1030 if (config_defines != NULL) {
1031 char *macroname = get_macro_id_from_ref(yytext);
1033 const char *macrovalue =
1034 string_map_get_bykey(config_defines, macroname, ¯olen);
1035 if (macrovalue != NULL) {
1036 if (!strcmp(macrovalue, "true")) yylval.bool_val = TRUE;
1037 else if (!strcmp(macrovalue, "false")) yylval.bool_val = FALSE;
1039 config_process_error_f("Macro `%s' cannot be interpreted as boolean "
1040 "value: `%s'", macroname, macrovalue);
1041 yylval.bool_val = FALSE;
1044 config_process_error_f("No macro or environmental variable defined"
1045 " with name `%s'", macroname);
1046 yylval.bool_val = FALSE;
1050 config_process_error("Internal error: Macro reference cannot be used in "
1052 yylval.bool_val = FALSE;
1054 return BooleanValue;
1058 if (config_defines != NULL) {
1059 char *macroname = get_macro_id_from_ref(yytext);
1061 const char *macrovalue =
1062 string_map_get_bykey(config_defines, macroname, ¯olen);
1063 if (macrovalue != NULL) {
1064 if (string_is_int(macrovalue, macrolen))
1065 yylval.int_val = new int_val_t(macrovalue);
1067 config_process_error_f("Macro `%s' cannot be interpreted as integer "
1068 "value: `%s'", macroname, macrovalue);
1069 yylval.int_val = new int_val_t((RInt)0);
1072 config_process_error_f("No macro or environmental variable defined"
1073 " with name `%s'", macroname);
1074 yylval.int_val = new int_val_t((RInt)0);
1078 config_process_error("Internal error: Macro reference cannot be used in "
1080 yylval.int_val = new int_val_t((RInt)0);
1086 if (config_defines != NULL) {
1087 char *macroname = get_macro_id_from_ref(yytext);
1089 const char *macrovalue =
1090 string_map_get_bykey(config_defines, macroname, ¯olen);
1091 if (macrovalue != NULL) {
1092 if (string_is_float(macrovalue, macrolen))
1093 yylval.float_val = atof(macrovalue);
1095 config_process_error_f("Macro `%s' cannot be interpreted as float value: "
1096 "`%s'", macroname, macrovalue);
1097 yylval.float_val = 0.0;
1100 config_process_error_f("No macro or environmental variable defined"
1101 " with name `%s'", macroname);
1102 yylval.float_val = 0.0;
1106 config_process_error("Internal error: Macro reference cannot be used in "
1108 yylval.float_val = 0.0;
1114 if (config_defines != NULL) {
1115 char *macroname = get_macro_id_from_ref(yytext);
1117 const char *macrovalue =
1118 string_map_get_bykey(config_defines, macroname, ¯olen);
1119 boolean is_asn = FALSE;
1120 if (macrovalue != NULL) {
1121 if (string_is_id(macrovalue, macrolen)) {
1122 yylval.str_val = mcopystr(macrovalue);
1123 for (size_t i = 0; i < macrolen; i++) {
1124 if (yylval.str_val[i]=='-') {
1125 yylval.str_val[i] = '_';
1130 TTCN_warning("In line %d of configuration file: `%s' is not a valid"
1131 " TTCN-3 identifier. Did you mean `%s'?",
1132 current_line, macrovalue, yylval.str_val);
1134 config_process_error_f("Macro `%s' cannot be interpreted as identifier: "
1135 "`%s'", macroname, macrovalue);
1136 yylval.str_val = memptystr();
1139 config_process_error_f("No macro or environmental variable defined with "
1140 "name `%s'", macroname);
1141 yylval.str_val = memptystr();
1144 return is_asn ? ASN1LowerIdentifier : Identifier;
1146 config_process_error("Internal error: Macro reference cannot be used in "
1148 yylval.str_val = memptystr();
1154 if (config_defines == NULL) {
1155 config_process_error("Internal error: Macro reference cannot be used in "
1157 yylval.charstring_val.n_chars = 0;
1158 yylval.charstring_val.chars_ptr = memptystr();
1163 if (yytext[1] == '{') macroname = get_macro_id_from_ref(yytext);
1164 else macroname = mcopystr(yytext + 1);
1166 const char *macrovalue = string_map_get_bykey
1167 (config_defines, macroname, ¯olen);
1169 if (macrovalue == NULL) {
1170 config_process_error_f("No macro or environmental variable defined with name "
1172 yylval.charstring_val.n_chars=0;
1173 yylval.charstring_val.chars_ptr=memptystr();
1178 if (macrolen > 0 && macrovalue[0] == '{') { // structured
1179 main_buffer = YY_CURRENT_BUFFER;
1180 expansion_buffer = yy_scan_string(macrovalue);
1181 yy_switch_to_buffer(expansion_buffer);
1184 yylval.charstring_val.n_chars=macrolen;
1185 yylval.charstring_val.chars_ptr=(char*)Malloc(macrolen+1);
1186 memcpy(yylval.charstring_val.chars_ptr, macrovalue, macrolen+1);
1193 if (config_defines != NULL) {
1194 char *macroname = get_macro_id_from_ref(yytext);
1196 const char *macrovalue =
1197 string_map_get_bykey(config_defines, macroname, ¯olen);
1198 if (macrovalue != NULL) {
1199 if (string_is_bstr(macrovalue, macrolen)) {
1200 yylval.bitstring_val.n_bits = macrolen;
1201 int n_bytes = (yylval.bitstring_val.n_bits + 7) / 8;
1202 yylval.bitstring_val.bits_ptr = (unsigned char *)Malloc(n_bytes);
1203 memset(yylval.bitstring_val.bits_ptr, 0, n_bytes);
1204 for (int i = 0; i < yylval.bitstring_val.n_bits; i++)
1205 if (macrovalue[i] == '1')
1206 yylval.bitstring_val.bits_ptr[i/8] |= 1 << (i % 8);
1208 config_process_error_f("Macro `%s' cannot be interpreted as bitstring "
1209 "value: `%s'", macroname, macrovalue);
1210 yylval.bitstring_val.n_bits = 0;
1211 yylval.bitstring_val.bits_ptr = NULL;
1214 config_process_error_f("No macro or environmental variable defined with "
1215 "name `%s'", macroname);
1216 yylval.bitstring_val.n_bits = 0;
1217 yylval.bitstring_val.bits_ptr = NULL;
1221 config_process_error_f("Internal error: Macro reference cannot be used in "
1223 yylval.bitstring_val.n_bits = 0;
1224 yylval.bitstring_val.bits_ptr = NULL;
1230 if (config_defines != NULL) {
1231 char *macroname = get_macro_id_from_ref(yytext);
1233 const char *macrovalue =
1234 string_map_get_bykey(config_defines, macroname, ¯olen);
1235 if (macrovalue != NULL) {
1236 if(string_is_hstr(macrovalue, macrolen)) {
1237 yylval.hexstring_val.n_nibbles = macrolen;
1238 int n_bytes = (yylval.hexstring_val.n_nibbles + 1) / 2;
1239 yylval.hexstring_val.nibbles_ptr = (unsigned char *)Malloc(n_bytes);
1240 memset(yylval.hexstring_val.nibbles_ptr, 0, n_bytes);
1241 for (int i = 0; i < yylval.hexstring_val.n_nibbles; i++) {
1242 unsigned int hex_digit;
1243 sscanf(macrovalue+i, "%1x", &hex_digit);
1244 if(i % 2) yylval.hexstring_val.nibbles_ptr[i/2] |=
1246 else yylval.hexstring_val.nibbles_ptr[i/2] |= hex_digit;
1249 config_process_error_f("Macro `%s' cannot be interpreted as hexstring "
1250 "value: `%s'", macroname, macrovalue);
1251 yylval.hexstring_val.n_nibbles = 0;
1252 yylval.hexstring_val.nibbles_ptr = NULL;
1255 config_process_error_f("No macro or environmental variable defined with "
1256 "name `%s'", macroname);
1257 yylval.hexstring_val.n_nibbles = 0;
1258 yylval.hexstring_val.nibbles_ptr = NULL;
1262 config_process_error("Internal error: Macro reference cannot be used in "
1264 yylval.hexstring_val.n_nibbles = 0;
1265 yylval.hexstring_val.nibbles_ptr = NULL;
1271 if (config_defines != NULL) {
1272 char *macroname = get_macro_id_from_ref(yytext);
1274 const char *macrovalue =
1275 string_map_get_bykey(config_defines, macroname, ¯olen);
1276 if (macrovalue != NULL) {
1277 if (string_is_ostr(macrovalue, macrolen)) {
1278 yylval.octetstring_val.n_octets = macrolen / 2;
1279 yylval.octetstring_val.octets_ptr = (unsigned char *)
1280 Malloc(yylval.octetstring_val.n_octets);
1281 for (int i = 0; i < yylval.octetstring_val.n_octets; i++) {
1282 unsigned int this_octet;
1283 sscanf(macrovalue+2*i, "%2x", &this_octet);
1284 yylval.octetstring_val.octets_ptr[i] = this_octet;
1287 config_process_error_f("Macro `%s' cannot be interpreted as octetstring "
1288 "value: `%s'", macroname, macrovalue);
1289 yylval.octetstring_val.n_octets = 0;
1290 yylval.octetstring_val.octets_ptr = NULL;
1293 config_process_error_f("No macro or environmental variable defined with "
1294 "name `%s'", macroname);
1295 yylval.octetstring_val.n_octets = 0;
1296 yylval.octetstring_val.octets_ptr = NULL;
1300 config_process_error_f("Internal error: Macro reference cannot be used in "
1302 yylval.octetstring_val.n_octets = 0;
1303 yylval.octetstring_val.octets_ptr = NULL;
1309 if (config_defines != NULL) {
1310 char *macroname = get_macro_id_from_ref(yytext);
1312 const char *macrovalue =
1313 string_map_get_bykey(config_defines, macroname, ¯olen);
1314 if (macrovalue != NULL) {
1315 yylval.octetstring_val.n_octets=macrolen;
1316 yylval.octetstring_val.octets_ptr = (unsigned char*)Malloc(macrolen);
1317 memcpy(yylval.octetstring_val.octets_ptr, macrovalue, macrolen);
1320 config_process_error_f("No macro or environmental variable defined with "
1321 "name `%s'", macroname);
1322 yylval.octetstring_val.n_octets = 0;
1323 yylval.octetstring_val.octets_ptr = NULL;
1327 config_process_error("Internal error: Macro reference cannot be used in "
1329 yylval.octetstring_val.n_octets = 0;
1330 yylval.octetstring_val.octets_ptr = NULL;
1336 if (config_defines != NULL) {
1337 char *macroname = get_macro_id_from_ref(yytext);
1339 const char *macrovalue =
1340 string_map_get_bykey(config_defines, macroname, ¯olen);
1341 if (macrovalue != NULL) {
1342 if (!string_is_hostname(macrovalue, macrolen)) {
1343 config_process_error_f("Macro `%s' cannot be interpreted as host name: "
1344 "`%s'", macroname, macrovalue);
1347 config_process_error_f("No macro or environmental variable defined with "
1348 "name `%s'", macroname);
1352 config_process_error("Internal error: Macro reference cannot be used in "
1358 ":="|"=" return AssignmentChar;
1359 "&=" return ConcatChar;
1362 if (expansion_buffer) {
1363 yy_switch_to_buffer(main_buffer);
1364 yy_delete_buffer(expansion_buffer);
1365 expansion_buffer = NULL;
1367 if (include_chain->size() > 1) {
1368 yy_delete_buffer(YY_CURRENT_BUFFER);
1369 fclose(include_chain->back().fp);
1370 include_chain->pop_back();
1371 yy_switch_to_buffer(include_chain->back().buffer_state);
1372 current_line = include_chain->back().line_number;
1373 BEGIN(SC_ORDERED_INCLUDE);
1388 void reset_config_process_lex(const char* fname)
1390 if (!include_chain) {
1391 include_chain = new std::deque<IncludeElem<YY_BUFFER_STATE> >();
1396 include_chain->push_back(IncludeElem<YY_BUFFER_STATE>(std::string(fname), config_process_in));
1400 void config_process_close() {
1401 delete include_chain;
1402 include_chain = NULL;
1405 int config_process_get_current_line()
1407 return current_line;