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