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