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
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}TESTPORT_PARAMETERS{WS}"]" {
189 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
190 BEGIN(SC_TESTPORT_PARAMETERS);
191 return TestportParametersKeyword;
195 <*>"["{WS}EXECUTE{WS}"]" {
196 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
198 return ExecuteKeyword;
202 <*>"["{WS}EXTERNAL_COMMANDS{WS}"]" {
203 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
204 BEGIN(SC_EXTERNAL_COMMANDS);
205 return ExternalCommandsKeyword;
209 <*>"["{WS}GROUPS{WS}"]" {
210 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
212 return GroupsKeyword;
216 <*>"["{WS}COMPONENTS{WS}"]" {
217 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
218 BEGIN(SC_COMPONENTS);
219 return ComponentsKeyword;
223 <*>"["{WS}MAIN_CONTROLLER{WS}"]" {
224 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
225 BEGIN(SC_MAIN_CONTROLLER);
226 return MainControllerKeyword;
230 <*>"["{WS}INCLUDE{WS}"]" {
231 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
233 return IncludeKeyword;
237 <*>"["{WS}ORDERED_INCLUDE{WS}"]" {
238 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
239 BEGIN(SC_ORDERED_INCLUDE);
243 <*>"["{WS}DEFINE{WS}"]" {
244 if (YY_START!=SC_commentblock && YY_START!=SC_cstring) {
246 return DefineKeyword;
250 /* Rules for SC_DEFINE must precede everything else */
255 caller_state = SC_DEFINE;
256 BEGIN(SC_commentblock);
260 caller_state = SC_DEFINE;
263 cstring_start = current_line;
266 {LINECOMMENT}|{NEWLINE} current_line++;
270 . /* eat unnecessary chars */
277 yylval.int_val = new int_val_t(yytext);
282 yylval.float_val = atof(yytext);
287 yylval.bitstring_val.n_bits = yyleng - 3;
288 int n_bytes = (yylval.bitstring_val.n_bits + 7) / 8;
289 yylval.bitstring_val.bits_ptr = (unsigned char *)Malloc(n_bytes);
290 memset(yylval.bitstring_val.bits_ptr, 0, n_bytes);
291 for (int i = 0; i < yylval.bitstring_val.n_bits; i++)
292 if (yytext[i+1] == '1')
293 yylval.bitstring_val.bits_ptr[i/8] |= 1 << (i % 8);
298 yylval.str_val = mcopystrn(yytext+1, yyleng-3);
303 config_process_error("Invalid bitstring value.");
304 yylval.bitstring_val.n_bits = 0;
305 yylval.bitstring_val.bits_ptr = NULL;
310 yylval.hexstring_val.n_nibbles = yyleng - 3;
311 int n_bytes = (yylval.hexstring_val.n_nibbles + 1) / 2;
312 yylval.hexstring_val.nibbles_ptr = (unsigned char *)Malloc(n_bytes);
313 memset(yylval.hexstring_val.nibbles_ptr, 0, n_bytes);
314 for (int i = 0; i < yylval.hexstring_val.n_nibbles; i++) {
315 unsigned int hex_digit;
316 sscanf(yytext+i+1, "%1x", &hex_digit);
317 if(i % 2) yylval.hexstring_val.nibbles_ptr[i/2] |=
319 else yylval.hexstring_val.nibbles_ptr[i/2] |= hex_digit;
325 yylval.str_val = mcopystrn(yytext+1, yyleng-3);
330 config_process_error("Invalid hexstring value.");
331 yylval.hexstring_val.n_nibbles = 0;
332 yylval.hexstring_val.nibbles_ptr = NULL;
337 yylval.octetstring_val.n_octets = (yyleng - 3) / 2;
338 yylval.octetstring_val.octets_ptr = (unsigned char *)
339 Malloc(yylval.octetstring_val.n_octets);
341 for (int i = 0; i < yylval.octetstring_val.n_octets; i++) {
342 unsigned int this_octet;
343 sscanf(yytext+2*i+1, "%2x", &this_octet);
344 yylval.octetstring_val.octets_ptr[i] = this_octet;
350 yylval.str_val = mcopystrn(yytext+1, yyleng-3);
355 config_process_error("Invalid octetstring value.");
356 yylval.octetstring_val.n_octets = 0;
357 yylval.octetstring_val.octets_ptr = NULL;
361 {BINSTRING_BAD} config_process_error("Invalid string value.");
363 ' config_process_error("Unmatched ' character.");
366 caller_state = YY_START;
369 cstring_start = current_line;
376 /* end of the string */
378 switch (caller_state) {
382 case SC_ORDERED_INCLUDE:
384 std::string error_msg = switch_lexer(include_chain, cstring,
385 YY_CURRENT_BUFFER, yy_create_buffer, yy_switch_to_buffer,
386 current_line, YY_BUF_SIZE);
387 if (error_msg.empty()) {
390 config_process_error(error_msg.c_str());
395 set_ret_val_cstr(cstring);
402 \\[\\'"?] cstring += yytext[1]; /* backslash-quoted \ or " or ' or ? */
403 \\{NEWLINE} current_line++;
413 sscanf(yytext + 1, "%o", &c);
415 config_process_error("Invalid octal character code in string "
417 else if (c == 0 && caller_state != SC_MODULE_PARAMETERS)
418 config_process_error("NUL characters in string literals are "
419 "allowed only in section [MODULE_PARAMETERS].");
424 sscanf(yytext + 2, "%x", &c);
425 if (c == 0 && caller_state != SC_MODULE_PARAMETERS)
426 config_process_error("NUL characters in string literals are "
427 "allowed only in section [MODULE_PARAMETERS].");
431 config_process_error("Invalid escape sequence in string literal.");
434 cstring.append(yytext, yyleng);
437 . cstring += yytext[0];
439 if (cstring_start >=0) {
440 config_process_error_f("Unterminated string literal starting at line %d "
441 "(missing \" at the end of file).", cstring_start);
443 config_process_error("Unterminated string literal (missing \" at the "
447 if (caller_state!=SC_DEFINE) {
448 set_ret_val_cstr(cstring);
456 /* Section-wide keywords */
458 <SC_MODULE_PARAMETERS>
460 NULL return NULLKeyword;
461 null return nullKeyword;
462 char return CharKeyword;
463 objid return ObjIdKeyword;
464 omit return OmitKeyword;
466 yylval.verdict_val = NONE;
470 yylval.verdict_val = PASS;
474 yylval.verdict_val = INCONC;
478 yylval.verdict_val = FAIL;
482 yylval.verdict_val = ERROR;
485 complement return ComplementKeyword;
486 "\.\." return DotDot;
487 superset return SupersetKeyword;
488 subset return SubsetKeyword;
489 pattern return PatternKeyword;
490 permutation return PermutationKeyword;
491 length return LengthKeyword;
492 ifpresent return IfpresentKeyword;
493 infinity return InfinityKeyword;
496 <SC_MODULE_PARAMETERS,SC_LOGGING>
499 yylval.bool_val = TRUE;
503 yylval.bool_val = FALSE;
508 /* We could add SC_LOGGING to make mtc and system special for the logging section too */
509 <SC_MODULE_PARAMETERS,SC_STRING2TTCN_COMPONENT,SC_TESTPORT_PARAMETERS,SC_LOGGING>
511 mtc return MTCKeyword;
512 system return SystemKeyword;
518 [Ll]og[Ff]ile return LogFile;
520 [Ee]mergency[Ll]ogging return EmergencyLogging;
522 [Ee]mergency[Ll]ogging[Bb]ehaviour return EmergencyLoggingBehaviour;
524 [Ee]mergency[Ll]ogging[Mm]ask return EmergencyLoggingMask;
526 [Ff]ile[Mm]ask return FileMask;
528 [Cc]onsole[Mm]ask return ConsoleMask;
530 [Tt]ime[Ss]tamp[Ff]ormat return TimestampFormat;
531 [Cc]onsole[Tt]ime[Ss]tamp[Ff]ormat return ConsoleTimestampFormat;
533 [Ll]og[Ss]ource[Ii]nfo |
534 [Ss]ource[Ii]nfo[Ff]ormat return SourceInfoFormat;
536 [Aa]ppend[Ff]ile return AppendFile;
538 [Ll]og[Ee]vent[Tt]ypes return LogEventTypes;
540 [Ll]og[Ee]ntity[Nn]ame return LogEntityName;
542 [Ll]og[Ff]ile[Ss]ize return LogFileSize;
544 [Ll]og[Ff]ile[Nn]umber return LogFileNumber;
546 [Dd]isk[Ff]ull[Aa]ction return DiskFullAction;
548 [Mm]atching[Hh]ints return MatchingHints;
550 [Ll]ogger[Pp]lugins return LoggerPlugins;
552 /* Lexer's handling of logging keywords:
554 * For sub-categories and categories with only one member,
555 * LoggingBit is returned and the value is the corresponding
556 * TTCN_Logger::Severity.
558 * For the old categories which now have subcategories, the old keyword
559 * is returned as LoggingBitCollection with the corresponding
560 * _UNQUALIFIED as the semantic value. The parser will construct the
563 * The lexer never returns a token with a Logging_Bits type.
566 yylval.logseverity_val = TTCN_Logger::NOTHING_TO_LOG;
571 yylval.logseverity_val = TTCN_Logger::ACTION_UNQUALIFIED;
575 yylval.logseverity_val = TTCN_Logger::ACTION_UNQUALIFIED;
576 return LoggingBitCollection;
580 yylval.logseverity_val = TTCN_Logger::DEBUG_ENCDEC;
584 yylval.logseverity_val = TTCN_Logger::DEBUG_TESTPORT;
588 yylval.logseverity_val = TTCN_Logger::DEBUG_UNQUALIFIED;
592 yylval.logseverity_val = TTCN_Logger::DEBUG_UNQUALIFIED;
593 return LoggingBitCollection;
597 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_ACTIVATE;
600 DEFAULTOP_DEACTIVATE {
601 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_DEACTIVATE;
605 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_EXIT;
608 DEFAULTOP_UNQUALIFIED {
609 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_UNQUALIFIED;
613 yylval.logseverity_val = TTCN_Logger::DEFAULTOP_UNQUALIFIED;
614 return LoggingBitCollection;
618 yylval.logseverity_val = TTCN_Logger::ERROR_UNQUALIFIED;
622 yylval.logseverity_val = TTCN_Logger::ERROR_UNQUALIFIED;
623 return LoggingBitCollection;
627 yylval.logseverity_val = TTCN_Logger::EXECUTOR_COMPONENT;
630 EXECUTOR_CONFIGDATA {
631 yylval.logseverity_val = TTCN_Logger::EXECUTOR_CONFIGDATA;
634 EXECUTOR_EXTCOMMAND {
635 yylval.logseverity_val = TTCN_Logger::EXECUTOR_EXTCOMMAND;
638 EXECUTOR_LOGOPTIONS {
639 yylval.logseverity_val = TTCN_Logger::EXECUTOR_LOGOPTIONS;
643 yylval.logseverity_val = TTCN_Logger::EXECUTOR_RUNTIME;
646 EXECUTOR_UNQUALIFIED {
647 yylval.logseverity_val = TTCN_Logger::EXECUTOR_UNQUALIFIED;
651 yylval.logseverity_val = TTCN_Logger::EXECUTOR_UNQUALIFIED;
652 return LoggingBitCollection;
656 yylval.logseverity_val = TTCN_Logger::FUNCTION_RND;
659 FUNCTION_UNQUALIFIED {
660 yylval.logseverity_val = TTCN_Logger::FUNCTION_UNQUALIFIED;
664 yylval.logseverity_val = TTCN_Logger::FUNCTION_UNQUALIFIED;
665 return LoggingBitCollection;
669 yylval.logseverity_val = TTCN_Logger::MATCHING_DONE;
673 yylval.logseverity_val = TTCN_Logger::MATCHING_MCSUCCESS;
677 yylval.logseverity_val = TTCN_Logger::MATCHING_MCUNSUCC;
681 yylval.logseverity_val = TTCN_Logger::MATCHING_MMSUCCESS;
685 yylval.logseverity_val = TTCN_Logger::MATCHING_MMUNSUCC;
689 yylval.logseverity_val = TTCN_Logger::MATCHING_PCSUCCESS;
693 yylval.logseverity_val = TTCN_Logger::MATCHING_PCUNSUCC;
697 yylval.logseverity_val = TTCN_Logger::MATCHING_PMSUCCESS;
701 yylval.logseverity_val = TTCN_Logger::MATCHING_PMUNSUCC;
705 yylval.logseverity_val = TTCN_Logger::MATCHING_PROBLEM;
709 yylval.logseverity_val = TTCN_Logger::MATCHING_TIMEOUT;
712 MATCHING_UNQUALIFIED {
713 yylval.logseverity_val = TTCN_Logger::MATCHING_UNQUALIFIED;
717 yylval.logseverity_val = TTCN_Logger::MATCHING_UNQUALIFIED;
718 return LoggingBitCollection;
722 yylval.logseverity_val = TTCN_Logger::PARALLEL_PORTCONN;
726 yylval.logseverity_val = TTCN_Logger::PARALLEL_PORTMAP;
730 yylval.logseverity_val = TTCN_Logger::PARALLEL_PTC;
733 PARALLEL_UNQUALIFIED {
734 yylval.logseverity_val = TTCN_Logger::PARALLEL_UNQUALIFIED;
738 yylval.logseverity_val = TTCN_Logger::PARALLEL_UNQUALIFIED;
739 return LoggingBitCollection;
743 yylval.logseverity_val = TTCN_Logger::PORTEVENT_DUALRECV;
747 yylval.logseverity_val = TTCN_Logger::PORTEVENT_DUALSEND;
751 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MCRECV;
755 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MCSEND;
759 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MMRECV;
763 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MMSEND;
767 yylval.logseverity_val = TTCN_Logger::PORTEVENT_MQUEUE;
771 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PCIN;
775 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PCOUT;
779 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PMIN;
783 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PMOUT;
787 yylval.logseverity_val = TTCN_Logger::PORTEVENT_PQUEUE;
791 yylval.logseverity_val = TTCN_Logger::PORTEVENT_STATE;
794 PORTEVENT_UNQUALIFIED {
795 yylval.logseverity_val = TTCN_Logger::PORTEVENT_UNQUALIFIED;
799 yylval.logseverity_val = TTCN_Logger::PORTEVENT_UNQUALIFIED;
800 return LoggingBitCollection;
803 STATISTICS_UNQUALIFIED {
804 yylval.logseverity_val = TTCN_Logger::STATISTICS_UNQUALIFIED;
808 yylval.logseverity_val = TTCN_Logger::STATISTICS_VERDICT;
812 yylval.logseverity_val = TTCN_Logger::STATISTICS_UNQUALIFIED;
813 return LoggingBitCollection;
817 yylval.logseverity_val = TTCN_Logger::TESTCASE_FINISH;
821 yylval.logseverity_val = TTCN_Logger::TESTCASE_START;
824 TESTCASE_UNQUALIFIED {
825 yylval.logseverity_val = TTCN_Logger::TESTCASE_UNQUALIFIED;
829 yylval.logseverity_val = TTCN_Logger::TESTCASE_UNQUALIFIED;
830 return LoggingBitCollection;
834 yylval.logseverity_val = TTCN_Logger::TIMEROP_GUARD;
838 yylval.logseverity_val = TTCN_Logger::TIMEROP_READ;
842 yylval.logseverity_val = TTCN_Logger::TIMEROP_START;
846 yylval.logseverity_val = TTCN_Logger::TIMEROP_STOP;
850 yylval.logseverity_val = TTCN_Logger::TIMEROP_TIMEOUT;
853 TIMEROP_UNQUALIFIED {
854 yylval.logseverity_val = TTCN_Logger::TIMEROP_UNQUALIFIED;
858 yylval.logseverity_val = TTCN_Logger::TIMEROP_UNQUALIFIED;
859 return LoggingBitCollection;
863 yylval.logseverity_val = TTCN_Logger::USER_UNQUALIFIED;
867 yylval.logseverity_val = TTCN_Logger::USER_UNQUALIFIED;
868 return LoggingBitCollection;
872 yylval.logseverity_val = TTCN_Logger::VERDICTOP_FINAL;
875 VERDICTOP_GETVERDICT {
876 yylval.logseverity_val = TTCN_Logger::VERDICTOP_GETVERDICT;
879 VERDICTOP_SETVERDICT {
880 yylval.logseverity_val = TTCN_Logger::VERDICTOP_SETVERDICT;
883 VERDICTOP_UNQUALIFIED {
884 yylval.logseverity_val = TTCN_Logger::VERDICTOP_UNQUALIFIED;
888 yylval.logseverity_val = TTCN_Logger::VERDICTOP_UNQUALIFIED;
889 return LoggingBitCollection;
892 WARNING_UNQUALIFIED {
893 yylval.logseverity_val = TTCN_Logger::WARNING_UNQUALIFIED;
897 yylval.logseverity_val = TTCN_Logger::WARNING_UNQUALIFIED;
898 return LoggingBitCollection;
902 yylval.logseverity_val = TTCN_Logger::LOG_ALL_IMPORTANT;
903 return LoggingBitCollection;
907 yylval.timestamp_value = TTCN_Logger::TIMESTAMP_TIME;
908 return TimestampValue;
910 [Dd][Aa][Tt][Ee][Tt][Ii][Mm][Ee] {
911 yylval.timestamp_value = TTCN_Logger::TIMESTAMP_DATETIME;
912 return TimestampValue;
914 [Ss][Ee][Cc][Oo][Nn][Dd][Ss] {
915 yylval.timestamp_value = TTCN_Logger::TIMESTAMP_SECONDS;
916 return TimestampValue;
919 yylval.source_info_value = TTCN_Logger::SINFO_NONE;
920 return SourceInfoValue;
922 [Ss][Ii][Nn][Gg][Ll][Ee] {
923 yylval.source_info_value = TTCN_Logger::SINFO_SINGLE;
924 return SourceInfoValue;
926 [Ss][Tt][Aa][Cc][Kk] {
927 yylval.source_info_value = TTCN_Logger::SINFO_STACK;
928 return SourceInfoValue;
931 yylval.bool_val = TRUE;
935 yylval.bool_val = FALSE;
939 yylval.emergency_logging_behaviour_value = TTCN_Logger::BUFFER_ALL;
940 return EmergencyLoggingBehaviourValue;
943 yylval.emergency_logging_behaviour_value = TTCN_Logger::BUFFER_MASKED;
944 return EmergencyLoggingBehaviourValue;
947 [Cc]ompact return Compact;
948 [Dd]etailed return Detailed;
949 [Ss]ub[Cc]ategories return SubCategories;
951 [Ee]rror return Error;
955 [Rr]etry return Retry;
957 [Dd]elete return Delete;
960 <SC_EXECUTE>control return ControlKeyword;
962 <SC_EXTERNAL_COMMANDS>
964 [Bb]egin[Cc]ontrol[Pp]art return BeginControlPart;
965 [Ee]nd[Cc]ontrol[Pp]art return EndControlPart;
966 [Bb]egin[Tt]est[Cc]ase return BeginTestCase;
967 [Ee]nd[Tt]est[Cc]ase return EndTestCase;
972 [Ll]ocal[Aa]ddress return LocalAddress;
973 [Tt][Cc][Pp][Pp]ort return TCPPort;
974 [Kk]ill[Tt]imer return KillTimer;
975 [Nn]um[Hh][Cc]s return NumHCs;
976 [Uu]nix[Ss]ockets[Ee]nabled return UnixSocketEnabled;
977 [Yy][Ee][Ss] return YesToken;
978 [Nn][Oo] return NoToken;
982 yylval.str_val = mcopystr(yytext);
986 <SC_MODULE_PARAMETERS>{ASN1LOWERIDENTIFIER} {
987 yylval.str_val = mcopystr(yytext);
988 for (int i = 0; i < yyleng; i++) {
989 if (yylval.str_val[i] == '-') yylval.str_val[i] = '_';
991 TTCN_warning("In line %d of configuration file: `%s' is not a valid TTCN-3 "
992 "identifier. Did you mean `%s'?", current_line, yytext, yylval.str_val);
993 return ASN1LowerIdentifier;
996 <SC_GROUPS,SC_COMPONENTS,SC_MAIN_CONTROLLER>{DNSNAME}|{IPV6} return DNSName;
997 /* Information is discarded ! */
999 <SC_STRING2TTCN_COMPONENT>{COMPONENT} {
1000 /* Ignore the component name, just return its number */
1001 size_t len = strlen(yytext);
1002 size_t pos = len - 1;
1003 while(yytext[pos] != '(' && pos != 0) {
1006 char* comp_num_str = mcopystrn(yytext + pos + 1, len - pos - 1);
1007 yylval.int_val = new int_val_t(comp_num_str);
1013 if (config_defines != NULL) {
1014 char *macroname = get_macro_id_from_ref(yytext);
1016 const char *macrovalue =
1017 string_map_get_bykey(config_defines, macroname, ¯olen);
1018 if (macrovalue != NULL) {
1019 if (!strcmp(macrovalue, "true")) yylval.bool_val = TRUE;
1020 else if (!strcmp(macrovalue, "false")) yylval.bool_val = FALSE;
1022 config_process_error_f("Macro `%s' cannot be interpreted as boolean "
1023 "value: `%s'", macroname, macrovalue);
1024 yylval.bool_val = FALSE;
1027 config_process_error_f("No macro or environmental variable defined"
1028 " with name `%s'", macroname);
1029 yylval.bool_val = FALSE;
1033 config_process_error("Internal error: Macro reference cannot be used in "
1035 yylval.bool_val = FALSE;
1037 return BooleanValue;
1041 if (config_defines != NULL) {
1042 char *macroname = get_macro_id_from_ref(yytext);
1044 const char *macrovalue =
1045 string_map_get_bykey(config_defines, macroname, ¯olen);
1046 if (macrovalue != NULL) {
1047 if (string_is_int(macrovalue, macrolen))
1048 yylval.int_val = new int_val_t(macrovalue);
1050 config_process_error_f("Macro `%s' cannot be interpreted as integer "
1051 "value: `%s'", macroname, macrovalue);
1052 yylval.int_val = new int_val_t((RInt)0);
1055 config_process_error_f("No macro or environmental variable defined"
1056 " with name `%s'", macroname);
1057 yylval.int_val = new int_val_t((RInt)0);
1061 config_process_error("Internal error: Macro reference cannot be used in "
1063 yylval.int_val = new int_val_t((RInt)0);
1069 if (config_defines != NULL) {
1070 char *macroname = get_macro_id_from_ref(yytext);
1072 const char *macrovalue =
1073 string_map_get_bykey(config_defines, macroname, ¯olen);
1074 if (macrovalue != NULL) {
1075 if (string_is_float(macrovalue, macrolen))
1076 yylval.float_val = atof(macrovalue);
1078 config_process_error_f("Macro `%s' cannot be interpreted as float value: "
1079 "`%s'", macroname, macrovalue);
1080 yylval.float_val = 0.0;
1083 config_process_error_f("No macro or environmental variable defined"
1084 " with name `%s'", macroname);
1085 yylval.float_val = 0.0;
1089 config_process_error("Internal error: Macro reference cannot be used in "
1091 yylval.float_val = 0.0;
1097 if (config_defines != NULL) {
1098 char *macroname = get_macro_id_from_ref(yytext);
1100 const char *macrovalue =
1101 string_map_get_bykey(config_defines, macroname, ¯olen);
1102 boolean is_asn = FALSE;
1103 if (macrovalue != NULL) {
1104 if (string_is_id(macrovalue, macrolen)) {
1105 yylval.str_val = mcopystr(macrovalue);
1106 for (size_t i = 0; i < macrolen; i++) {
1107 if (yylval.str_val[i]=='-') {
1108 yylval.str_val[i] = '_';
1113 TTCN_warning("In line %d of configuration file: `%s' is not a valid"
1114 " TTCN-3 identifier. Did you mean `%s'?",
1115 current_line, macrovalue, yylval.str_val);
1117 config_process_error_f("Macro `%s' cannot be interpreted as identifier: "
1118 "`%s'", macroname, macrovalue);
1119 yylval.str_val = memptystr();
1122 config_process_error_f("No macro or environmental variable defined with "
1123 "name `%s'", macroname);
1124 yylval.str_val = memptystr();
1127 return is_asn ? ASN1LowerIdentifier : Identifier;
1129 config_process_error("Internal error: Macro reference cannot be used in "
1131 yylval.str_val = memptystr();
1137 if (config_defines == NULL) {
1138 config_process_error("Internal error: Macro reference cannot be used in "
1140 yylval.charstring_val.n_chars = 0;
1141 yylval.charstring_val.chars_ptr = memptystr();
1146 if (yytext[1] == '{') macroname = get_macro_id_from_ref(yytext);
1147 else macroname = mcopystr(yytext + 1);
1149 const char *macrovalue = string_map_get_bykey
1150 (config_defines, macroname, ¯olen);
1152 if (macrovalue == NULL) {
1153 config_process_error_f("No macro or environmental variable defined with name "
1155 yylval.charstring_val.n_chars=0;
1156 yylval.charstring_val.chars_ptr=memptystr();
1161 if (macrolen > 0 && macrovalue[0] == '{') { // structured
1162 main_buffer = YY_CURRENT_BUFFER;
1163 expansion_buffer = yy_scan_string(macrovalue);
1164 yy_switch_to_buffer(expansion_buffer);
1167 yylval.charstring_val.n_chars=macrolen;
1168 yylval.charstring_val.chars_ptr=(char*)Malloc(macrolen+1);
1169 memcpy(yylval.charstring_val.chars_ptr, macrovalue, macrolen+1);
1176 if (config_defines != NULL) {
1177 char *macroname = get_macro_id_from_ref(yytext);
1179 const char *macrovalue =
1180 string_map_get_bykey(config_defines, macroname, ¯olen);
1181 if (macrovalue != NULL) {
1182 if (string_is_bstr(macrovalue, macrolen)) {
1183 yylval.bitstring_val.n_bits = macrolen;
1184 int n_bytes = (yylval.bitstring_val.n_bits + 7) / 8;
1185 yylval.bitstring_val.bits_ptr = (unsigned char *)Malloc(n_bytes);
1186 memset(yylval.bitstring_val.bits_ptr, 0, n_bytes);
1187 for (int i = 0; i < yylval.bitstring_val.n_bits; i++)
1188 if (macrovalue[i] == '1')
1189 yylval.bitstring_val.bits_ptr[i/8] |= 1 << (i % 8);
1191 config_process_error_f("Macro `%s' cannot be interpreted as bitstring "
1192 "value: `%s'", macroname, macrovalue);
1193 yylval.bitstring_val.n_bits = 0;
1194 yylval.bitstring_val.bits_ptr = NULL;
1197 config_process_error_f("No macro or environmental variable defined with "
1198 "name `%s'", macroname);
1199 yylval.bitstring_val.n_bits = 0;
1200 yylval.bitstring_val.bits_ptr = NULL;
1204 config_process_error_f("Internal error: Macro reference cannot be used in "
1206 yylval.bitstring_val.n_bits = 0;
1207 yylval.bitstring_val.bits_ptr = NULL;
1213 if (config_defines != NULL) {
1214 char *macroname = get_macro_id_from_ref(yytext);
1216 const char *macrovalue =
1217 string_map_get_bykey(config_defines, macroname, ¯olen);
1218 if (macrovalue != NULL) {
1219 if(string_is_hstr(macrovalue, macrolen)) {
1220 yylval.hexstring_val.n_nibbles = macrolen;
1221 int n_bytes = (yylval.hexstring_val.n_nibbles + 1) / 2;
1222 yylval.hexstring_val.nibbles_ptr = (unsigned char *)Malloc(n_bytes);
1223 memset(yylval.hexstring_val.nibbles_ptr, 0, n_bytes);
1224 for (int i = 0; i < yylval.hexstring_val.n_nibbles; i++) {
1225 unsigned int hex_digit;
1226 sscanf(macrovalue+i, "%1x", &hex_digit);
1227 if(i % 2) yylval.hexstring_val.nibbles_ptr[i/2] |=
1229 else yylval.hexstring_val.nibbles_ptr[i/2] |= hex_digit;
1232 config_process_error_f("Macro `%s' cannot be interpreted as hexstring "
1233 "value: `%s'", macroname, macrovalue);
1234 yylval.hexstring_val.n_nibbles = 0;
1235 yylval.hexstring_val.nibbles_ptr = NULL;
1238 config_process_error_f("No macro or environmental variable defined with "
1239 "name `%s'", macroname);
1240 yylval.hexstring_val.n_nibbles = 0;
1241 yylval.hexstring_val.nibbles_ptr = NULL;
1245 config_process_error("Internal error: Macro reference cannot be used in "
1247 yylval.hexstring_val.n_nibbles = 0;
1248 yylval.hexstring_val.nibbles_ptr = NULL;
1254 if (config_defines != NULL) {
1255 char *macroname = get_macro_id_from_ref(yytext);
1257 const char *macrovalue =
1258 string_map_get_bykey(config_defines, macroname, ¯olen);
1259 if (macrovalue != NULL) {
1260 if (string_is_ostr(macrovalue, macrolen)) {
1261 yylval.octetstring_val.n_octets = macrolen / 2;
1262 yylval.octetstring_val.octets_ptr = (unsigned char *)
1263 Malloc(yylval.octetstring_val.n_octets);
1264 for (int i = 0; i < yylval.octetstring_val.n_octets; i++) {
1265 unsigned int this_octet;
1266 sscanf(macrovalue+2*i, "%2x", &this_octet);
1267 yylval.octetstring_val.octets_ptr[i] = this_octet;
1270 config_process_error_f("Macro `%s' cannot be interpreted as octetstring "
1271 "value: `%s'", macroname, macrovalue);
1272 yylval.octetstring_val.n_octets = 0;
1273 yylval.octetstring_val.octets_ptr = NULL;
1276 config_process_error_f("No macro or environmental variable defined with "
1277 "name `%s'", macroname);
1278 yylval.octetstring_val.n_octets = 0;
1279 yylval.octetstring_val.octets_ptr = NULL;
1283 config_process_error_f("Internal error: Macro reference cannot be used in "
1285 yylval.octetstring_val.n_octets = 0;
1286 yylval.octetstring_val.octets_ptr = NULL;
1292 if (config_defines != NULL) {
1293 char *macroname = get_macro_id_from_ref(yytext);
1295 const char *macrovalue =
1296 string_map_get_bykey(config_defines, macroname, ¯olen);
1297 if (macrovalue != NULL) {
1298 yylval.octetstring_val.n_octets=macrolen;
1299 yylval.octetstring_val.octets_ptr = (unsigned char*)Malloc(macrolen);
1300 memcpy(yylval.octetstring_val.octets_ptr, macrovalue, macrolen);
1303 config_process_error_f("No macro or environmental variable defined with "
1304 "name `%s'", macroname);
1305 yylval.octetstring_val.n_octets = 0;
1306 yylval.octetstring_val.octets_ptr = NULL;
1310 config_process_error("Internal error: Macro reference cannot be used in "
1312 yylval.octetstring_val.n_octets = 0;
1313 yylval.octetstring_val.octets_ptr = NULL;
1319 if (config_defines != NULL) {
1320 char *macroname = get_macro_id_from_ref(yytext);
1322 const char *macrovalue =
1323 string_map_get_bykey(config_defines, macroname, ¯olen);
1324 if (macrovalue != NULL) {
1325 if (!string_is_hostname(macrovalue, macrolen)) {
1326 config_process_error_f("Macro `%s' cannot be interpreted as host name: "
1327 "`%s'", macroname, macrovalue);
1330 config_process_error_f("No macro or environmental variable defined with "
1331 "name `%s'", macroname);
1335 config_process_error("Internal error: Macro reference cannot be used in "
1341 ":="|"=" return AssignmentChar;
1342 "&=" return ConcatChar;
1345 if (expansion_buffer) {
1346 yy_switch_to_buffer(main_buffer);
1347 yy_delete_buffer(expansion_buffer);
1348 expansion_buffer = NULL;
1350 if (include_chain->size() > 1) {
1351 yy_delete_buffer(YY_CURRENT_BUFFER);
1352 fclose(include_chain->back().fp);
1353 include_chain->pop_back();
1354 yy_switch_to_buffer(include_chain->back().buffer_state);
1355 current_line = include_chain->back().line_number;
1356 BEGIN(SC_ORDERED_INCLUDE);
1371 void reset_config_process_lex(const char* fname)
1373 if (!include_chain) {
1374 include_chain = new std::deque<IncludeElem<YY_BUFFER_STATE> >();
1379 include_chain->push_back(IncludeElem<YY_BUFFER_STATE>(std::string(fname), config_process_in));
1383 void config_process_close() {
1384 delete include_chain;
1385 include_chain = NULL;
1388 int config_process_get_current_line()
1390 return current_line;