Commit | Line | Data |
---|---|---|
970ed795 EL |
1 | /****************************************************************************** |
2 | * Copyright (c) 2000-2014 Ericsson Telecom AB | |
3 | * All rights reserved. This program and the accompanying materials | |
4 | * are made available under the terms of the Eclipse Public License v1.0 | |
5 | * which accompanies this distribution, and is available at | |
6 | * http://www.eclipse.org/legal/epl-v10.html | |
7 | ******************************************************************************/ | |
8 | %option yylineno | |
9 | %option noyywrap | |
10 | %option never-interactive | |
11 | %option nounput | |
12 | ||
13 | %{ | |
14 | ||
15 | #include <string.h> | |
16 | #include <ctype.h> | |
17 | #include <stdlib.h> | |
18 | ||
19 | #include <deque> | |
20 | #include <string> | |
21 | ||
22 | #include <openssl/crypto.h> | |
23 | #include <openssl/bn.h> | |
24 | ||
25 | #include "../../common/cfg_process_utils.hh" | |
26 | #include "../../common/Path2.hh" | |
27 | #include "../../common/config_preproc.h" | |
28 | ||
29 | #include "../../common/memory.h" | |
30 | #include "../mctr/config_data.h" | |
31 | #include "../../core/Types.h" | |
32 | #include "config_read.tab.hh" | |
33 | ||
34 | //#include "../../common/dbgnew.hh" | |
35 | ||
36 | extern string_map_t *config_defines; | |
37 | ||
38 | #define yylval config_read_lval | |
39 | ||
40 | /* This buffer stores the state of the main buffer | |
41 | while the macro expansion is happening. */ | |
42 | static YY_BUFFER_STATE main_buffer = NULL; | |
43 | /* This buffer is active while the expansion of | |
44 | a reference to a structured macro definition is happening. | |
45 | Otherwise its value is NULL. */ | |
46 | static YY_BUFFER_STATE expansion_buffer = NULL; | |
47 | ||
48 | static void update_buffer(); | |
49 | static boolean whether_update_buffer(); | |
50 | ||
51 | #define RETURN(x) do {update_buffer(); return (x);} while(0) | |
52 | ||
53 | void config_read_warning(const char *warning_str, ...); | |
54 | extern void config_read_error(const char *error_str, ...); | |
55 | extern config_data *cfg; | |
56 | ||
57 | static std::deque<IncludeElem<YY_BUFFER_STATE> >* include_chain = NULL; | |
58 | ||
59 | std::string get_cfg_read_current_file() { | |
60 | if (include_chain && !include_chain->empty()) { | |
61 | return include_chain->back().get_full_path(); | |
62 | } | |
63 | return std::string(); | |
64 | } | |
65 | ||
66 | %} | |
67 | ||
68 | WHITESPACE [ \t] | |
69 | WS {WHITESPACE}* | |
70 | NEWLINE \r|\n|\r\n | |
71 | LINECOMMENT ("//"|"#")[^\r\n]*{NEWLINE} | |
72 | ||
73 | NUMBER 0|([1-9][0-9]*) | |
74 | ||
75 | FLOAT [+-]?({NUMBER}\.[0-9]+)|((({NUMBER}(\.[0-9]+)?)|(\.[0-9]+))[Ee][+-]?{NUMBER}) | |
76 | ||
77 | BIN 0|1 | |
78 | BITSTRING '{BIN}*'B | |
79 | BINMATCH 0|1|\?|\* | |
80 | BITSTRINGMATCH '{BINMATCH}*'B | |
81 | BITSTRING_BAD '[^']*'B | |
82 | ||
83 | HEX [0-9A-Fa-f] | |
84 | HEXSTRING '{HEX}*'H | |
85 | HEXMATCH [0-9A-Fa-f\?\*] | |
86 | HEXSTRINGMATCH '{HEXMATCH}*'H | |
87 | HEXSTRING_BAD '[^']*'H | |
88 | ||
89 | OCT {HEX}{HEX} | |
90 | OCTETSTRING '{OCT}*'O | |
91 | OCTMATCH {HEX}{HEX}|\?|\* | |
92 | OCTETSTRINGMATCH '{OCTMATCH}*'O | |
93 | OCTETSTRING_BAD '[^']*'O | |
94 | ||
95 | BINSTRING_BAD '[^']*' | |
96 | ||
97 | TTCN3IDENTIFIER [A-Za-z][A-Za-z0-9_]* | |
98 | ASN1LOWERIDENTIFIER [a-z](-?[A-Za-z0-9]+)* | |
99 | ||
100 | MACRORVALUE ([0-9A-Za-z._-]+)|{IPV6} | |
101 | MACRO_CSTR \${TTCN3IDENTIFIER}|\$"{"{WS}{TTCN3IDENTIFIER}{WS}(","{WS}charstring{WS})?"}" | |
102 | MACRO_BOOL \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}boolean{WS}"}" | |
103 | MACRO_FLOAT \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}float{WS}"}" | |
104 | MACRO_ID \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}identifier{WS}"}" | |
105 | MACRO_INT \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}integer{WS}"}" | |
106 | MACRO_BSTR \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}bitstring{WS}"}" | |
107 | MACRO_HSTR \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}hexstring{WS}"}" | |
108 | MACRO_OSTR \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}octetstring{WS}"}" | |
109 | MACRO_BINARY \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}binaryoctet{WS}"}" | |
110 | MACRO_HOSTNAME \$"{"{WS}{TTCN3IDENTIFIER}{WS}","{WS}hostname{WS}"}" | |
111 | ||
112 | CHAR [^\\\"]|\\([\\\'\"\?abfnrtv]|{NEWLINE}|[0-7]{1,3}|x{HEX}{1,2})|\"\" | |
113 | CHARSTRING \"{CHAR}*\" | |
114 | ||
115 | HOSTNAME [A-Za-z0-9]([A-Za-z0-9_\-]*[A-Za-z0-9])? | |
116 | DNSNAME {HOSTNAME}(\.{HOSTNAME})*\.? | |
117 | ||
118 | /* Example: fe80::c002:37ff:fe6c:0%fastethernet0/0 */ | |
119 | IPV6 [0-9A-Fa-f:.]+(%[0-9A-Za-z]+)? | |
120 | ||
121 | ||
122 | %x SC_blockcomment SC_DEFINE SC_CSTRING SC_ORDERED_INCLUDE | |
123 | %s SC_MODULE_PARAMETERS SC_LOGGING SC_TESTPORT_PARAMETERS SC_EXECUTE SC_GROUPS | |
af710487 | 124 | %s SC_COMPONENTS SC_EXTERNAL_COMMANDS SC_MAIN_CONTROLLER SC_INCLUDE SC_PROFILER |
970ed795 EL |
125 | |
126 | %% | |
127 | int comment_caller = INITIAL; | |
128 | ||
129 | std::string cstring; | |
130 | ||
131 | /* Eat up comments and whitespaces */ | |
132 | ||
133 | "/*" { | |
134 | comment_caller = YY_START; | |
135 | BEGIN(SC_blockcomment); | |
136 | } | |
137 | <SC_blockcomment> | |
138 | { | |
139 | "*/" BEGIN(comment_caller); | |
140 | .|\n | |
141 | } | |
142 | ||
143 | {LINECOMMENT}|{WHITESPACE}|{NEWLINE} | |
144 | ||
145 | /* Section delimiters */ | |
146 | ||
147 | <*>"["{WS}MODULE_PARAMETERS{WS}"]" { | |
148 | if (YY_START!=SC_blockcomment) { | |
149 | BEGIN(SC_MODULE_PARAMETERS); | |
150 | RETURN(ModuleParametersKeyword); | |
151 | } | |
152 | } | |
153 | ||
154 | <*>"["{WS}LOGGING{WS}"]" { | |
155 | if (YY_START!=SC_blockcomment) { | |
156 | BEGIN(SC_LOGGING); | |
157 | RETURN(LoggingKeyword); | |
158 | } | |
159 | } | |
160 | ||
af710487 | 161 | <*>"["{WS}PROFILER{WS}"]" { |
162 | if (YY_START!=SC_blockcomment) { | |
163 | BEGIN(SC_PROFILER); | |
164 | RETURN(ProfilerKeyword); | |
165 | } | |
166 | } | |
167 | ||
970ed795 EL |
168 | <*>"["{WS}TESTPORT_PARAMETERS{WS}"]" { |
169 | if (YY_START!=SC_blockcomment) { | |
170 | BEGIN(SC_TESTPORT_PARAMETERS); | |
171 | RETURN(TestportParametersKeyword); | |
172 | } | |
173 | } | |
174 | ||
175 | <*>"["{WS}EXECUTE{WS}"]" { | |
176 | if (YY_START!=SC_blockcomment) { | |
177 | BEGIN(SC_EXECUTE); | |
178 | RETURN(ExecuteKeyword); | |
179 | } | |
180 | } | |
181 | ||
182 | <*>"["{WS}EXTERNAL_COMMANDS{WS}"]" { | |
183 | if (YY_START!=SC_blockcomment) { | |
184 | BEGIN(SC_EXTERNAL_COMMANDS); | |
185 | RETURN(ExternalCommandsKeyword); | |
186 | } | |
187 | } | |
188 | ||
189 | <*>"["{WS}GROUPS{WS}"]" { | |
190 | if (YY_START!=SC_blockcomment) { | |
191 | BEGIN(SC_GROUPS); | |
192 | RETURN(GroupsKeyword); | |
193 | } | |
194 | } | |
195 | ||
196 | <*>"["{WS}COMPONENTS{WS}"]" { | |
197 | if (YY_START!=SC_blockcomment) { | |
198 | BEGIN(SC_COMPONENTS); | |
199 | RETURN(ComponentsKeyword); | |
200 | } | |
201 | } | |
202 | ||
203 | <*>"["{WS}MAIN_CONTROLLER{WS}"]" { | |
204 | if (YY_START!=SC_blockcomment) { | |
205 | BEGIN(SC_MAIN_CONTROLLER); | |
206 | RETURN(MainControllerKeyword); | |
207 | } | |
208 | } | |
209 | ||
210 | <*>"["{WS}INCLUDE{WS}"]" { | |
211 | if (YY_START!=SC_blockcomment) { | |
212 | BEGIN(SC_INCLUDE); | |
213 | RETURN(IncludeKeyword); | |
214 | } | |
215 | } | |
216 | ||
217 | <*>"["{WS}ORDERED_INCLUDE{WS}"]" { | |
218 | if (YY_START!=SC_blockcomment) { | |
219 | BEGIN(SC_ORDERED_INCLUDE); | |
220 | } | |
221 | } | |
222 | ||
223 | ||
224 | <*>"["{WS}DEFINE{WS}"]" { | |
225 | if (YY_START!=SC_blockcomment) { | |
226 | BEGIN(SC_DEFINE); | |
227 | RETURN(DefineKeyword); | |
228 | } | |
229 | } | |
230 | ||
231 | /* Rules for SC_DEFINE must precede everything else */ | |
232 | ||
233 | <SC_DEFINE>{ | |
234 | ||
235 | "/*" { | |
236 | comment_caller = SC_DEFINE; | |
237 | BEGIN(SC_blockcomment); | |
238 | } | |
239 | ||
240 | {CHARSTRING} /* eats string */ | |
241 | ||
242 | {LINECOMMENT} | |
243 | ||
244 | {NEWLINE} /* this is not in . */ | |
245 | ||
246 | \\\" | |
247 | ||
248 | . /* eats unnecessary things */ | |
249 | ||
250 | } | |
251 | ||
252 | <SC_ORDERED_INCLUDE>{ | |
253 | ||
254 | "/*" { | |
255 | comment_caller = YY_START; | |
256 | BEGIN(SC_blockcomment); | |
257 | } | |
258 | ||
259 | \" { BEGIN(SC_CSTRING); } | |
260 | ||
261 | {LINECOMMENT} | |
262 | ||
263 | {NEWLINE} /* this is not in . */ | |
264 | ||
265 | \\\" | |
266 | ||
267 | . /* eat unnecessary chars */ | |
268 | ||
269 | } | |
270 | ||
271 | ||
272 | <SC_CSTRING>{ | |
273 | ||
274 | \"\" cstring += '"'; | |
275 | ||
276 | \" { | |
277 | std::string error_msg = switch_lexer(include_chain, cstring, | |
278 | YY_CURRENT_BUFFER, yy_create_buffer, yy_switch_to_buffer, yylineno, | |
279 | YY_BUF_SIZE); | |
280 | if (error_msg.empty()) { | |
281 | BEGIN(INITIAL); | |
282 | } else { | |
283 | config_read_error(error_msg.c_str()); | |
284 | } | |
285 | ||
286 | cstring.clear(); | |
287 | } /* end of string */ | |
288 | ||
289 | \\[\\'"?] cstring += yytext[1]; /* backslash-quoted \ or " or ' or ? */ | |
290 | \\{NEWLINE} yylineno++; | |
291 | \\a cstring += '\a'; | |
292 | \\b cstring += '\b'; | |
293 | \\f cstring += '\f'; | |
294 | \\n cstring += '\n'; | |
295 | \\r cstring += '\r'; | |
296 | \\t cstring += '\t'; | |
297 | \\v cstring += '\v'; | |
298 | ||
299 | \\[0-7]{1,3} { | |
300 | unsigned int c; | |
301 | sscanf(yytext + 1, "%o", &c); | |
302 | if (c <= 255) cstring += c; | |
303 | else config_read_error("Invalid octal character code in string literal"); | |
304 | } | |
305 | ||
306 | \\x{HEX}{1,2} { | |
307 | unsigned int c; | |
308 | sscanf(yytext + 2, "%x", &c); | |
309 | cstring += c; | |
310 | } | |
311 | ||
312 | \\(x[^\\\"]|.) config_read_error("Invalid excape sequence in string literal."); | |
313 | ||
314 | {NEWLINE} { | |
315 | cstring.append(yytext, yyleng); | |
316 | yylineno++; | |
317 | } | |
318 | ||
319 | . { | |
320 | cstring += yytext[0]; | |
321 | } | |
322 | } | |
323 | /* SC_cstring */ | |
324 | ||
325 | ||
326 | /* Values */ | |
327 | ||
328 | {NUMBER} { | |
329 | yylval.int_val = NULL; | |
330 | BN_dec2bn(&yylval.int_val, *yytext == '+' ? yytext + 1 : yytext); | |
331 | RETURN(Number); | |
332 | } | |
333 | ||
334 | {FLOAT} { | |
335 | yylval.float_val = atof(yytext); | |
336 | RETURN(Float); | |
337 | } | |
338 | ||
339 | {BITSTRING} RETURN(Bstring); | |
340 | ||
341 | {BITSTRINGMATCH} RETURN(BstringMatch); | |
342 | ||
343 | {BITSTRING_BAD} { | |
344 | config_read_error("Invalid bitstring value."); | |
345 | RETURN(Bstring); | |
346 | } | |
347 | ||
348 | {HEXSTRING} RETURN(Hstring); | |
349 | ||
350 | {HEXSTRINGMATCH} RETURN(HstringMatch); | |
351 | ||
352 | {HEXSTRING_BAD} { | |
353 | config_read_error("Invalid hexstring value."); | |
354 | RETURN(Hstring); | |
355 | } | |
356 | ||
357 | {OCTETSTRING} RETURN(Ostring); | |
358 | ||
359 | {OCTETSTRINGMATCH} RETURN(OstringMatch); | |
360 | ||
361 | {OCTETSTRING_BAD} { | |
362 | config_read_error("Invalid octetstring value."); | |
363 | RETURN(Ostring); | |
364 | } | |
365 | ||
366 | {BINSTRING_BAD} config_read_error("Invalid string value."); | |
367 | ||
368 | ' config_read_error("Unmatched ' character."); | |
369 | ||
370 | {CHARSTRING} { | |
371 | yylval.str_val = mcopystrn(yytext, yyleng); | |
372 | RETURN(Cstring); | |
373 | } | |
374 | ||
375 | /* Section-wide keywords */ | |
376 | ||
377 | <SC_MODULE_PARAMETERS> | |
378 | { | |
379 | NULL RETURN(NULLKeyword); | |
380 | null RETURN(nullKeyword); | |
381 | char RETURN(CharKeyword); | |
382 | objid RETURN(ObjIdKeyword); | |
383 | omit RETURN(OmitKeyword); | |
384 | none | | |
385 | pass | | |
386 | inconc | | |
387 | fail | | |
388 | error RETURN(VerdictValue); | |
389 | complement RETURN(ComplementKeyword); | |
390 | "\.\." RETURN(DotDot); | |
391 | superset RETURN(SupersetKeyword); | |
392 | subset RETURN(SubsetKeyword); | |
393 | pattern RETURN(PatternKeyword); | |
394 | permutation RETURN(PermutationKeyword); | |
395 | length RETURN(LengthKeyword); | |
396 | ifpresent RETURN(IfpresentKeyword); | |
397 | infinity RETURN(InfinityKeyword); | |
398 | } | |
399 | ||
af710487 | 400 | <SC_MODULE_PARAMETERS,SC_LOGGING,SC_PROFILER> |
970ed795 EL |
401 | { |
402 | true | | |
403 | false RETURN(BooleanValue); | |
404 | } | |
405 | ||
406 | <SC_MODULE_PARAMETERS,SC_LOGGING,SC_TESTPORT_PARAMETERS> | |
407 | { | |
408 | mtc RETURN(MTCKeyword); | |
409 | system RETURN(SystemKeyword); | |
410 | } | |
411 | ||
412 | <SC_LOGGING> | |
413 | { | |
414 | [Ff]ile[Nn]ame | | |
415 | [Ll]og[Ff]ile RETURN(LogFile); | |
416 | ||
417 | [Ee]mergency[Ll]ogging RETURN(EmergencyLogging); | |
418 | ||
419 | [Ee]mergency[Ll]ogging[Bb]ehaviour RETURN(EmergencyLoggingBehaviour); | |
420 | ||
421 | [Bb]uffer[Aa]ll | | |
422 | [Bb]uffer[Ma]asked RETURN(EmergencyLoggingBehaviourValue); | |
423 | ||
424 | [Ee]mergency[Ll]ogging[Mm]ask RETURN(EmergencyLoggingMask); | |
425 | ||
426 | ||
427 | [Ff]ile[Mm]ask RETURN(FileMask); | |
428 | ||
429 | [Cc]onsole[Mm]ask RETURN(ConsoleMask); | |
430 | ||
431 | [Tt]ime[Ss]tamp[Ff]ormat RETURN(TimestampFormat); | |
432 | [Cc]onsole[Tt]ime[Ss]tamp[Ff]ormat RETURN(ConsoleTimestampFormat); | |
433 | ||
434 | [Ll]og[Ss]ource[Ii]nfo | | |
435 | [Ss]ource[Ii]nfo[Ff]ormat RETURN(SourceInfoFormat); | |
436 | ||
437 | [Aa]ppend[Ff]ile RETURN(AppendFile); | |
438 | ||
439 | [Ll]og[Ee]vent[Tt]ypes RETURN(LogEventTypes); | |
440 | ||
441 | [Ll]og[Ee]ntity[Nn]ame RETURN(LogEntityName); | |
442 | ||
443 | [Ll]og[Ff]ile[Ss]ize RETURN(LogFileSize); | |
444 | ||
445 | [Ll]og[Ff]ile[Nn]umber RETURN(LogFileNumber); | |
446 | ||
447 | [Dd]isk[Ff]ull[Aa]ction RETURN(DiskFullAction); | |
448 | ||
449 | [Mm]atching[Hh]ints RETURN(MatchingHints); | |
450 | ||
451 | [Ll]ogger[Pp]lugins RETURN(LoggerPlugins); | |
452 | ||
453 | LOG_NOTHING RETURN(LoggingBit); | |
454 | ||
455 | (TTCN_)?ACTION | | |
456 | (TTCN_)?DEBUG | | |
457 | (TTCN_)?DEFAULTOP | | |
458 | (TTCN_)?ERROR | | |
459 | (TTCN_)?EXECUTOR | | |
460 | (TTCN_)?FUNCTION | | |
461 | (TTCN_)?MATCHING | | |
462 | (TTCN_)?PARALLEL | | |
463 | (TTCN_)?PORTEVENT | | |
464 | (TTCN_)?STATISTICS | | |
465 | (TTCN_)?TESTCASE | | |
466 | (TTCN_)?TIMEROP | | |
467 | (TTCN_)?USER | | |
468 | (TTCN_)?VERDICTOP | | |
469 | (TTCN_)?WARNING | | |
470 | LOG_ALL RETURN(LoggingBitCollection); | |
471 | ||
472 | ACTION_UNQUALIFIED | | |
473 | DEBUG_ENCDEC | | |
474 | DEBUG_TESTPORT | | |
475 | DEBUG_UNQUALIFIED | | |
476 | DEFAULTOP_ACTIVATE | | |
477 | DEFAULTOP_DEACTIVATE | | |
478 | DEFAULTOP_EXIT | | |
479 | DEFAULTOP_UNQUALIFIED | | |
480 | ERROR_UNQUALIFIED | | |
481 | EXECUTOR_COMPONENT | | |
482 | EXECUTOR_CONFIGDATA | | |
483 | EXECUTOR_EXTCOMMAND | | |
484 | EXECUTOR_LOGOPTIONS | | |
485 | EXECUTOR_RUNTIME | | |
486 | EXECUTOR_UNQUALIFIED | | |
487 | FUNCTION_RND | | |
488 | FUNCTION_UNQUALIFIED | | |
489 | MATCHING_DONE | | |
490 | MATCHING_MCSUCCESS | | |
491 | MATCHING_MCUNSUCC | | |
492 | MATCHING_MMSUCCESS | | |
493 | MATCHING_MMUNSUCC | | |
494 | MATCHING_PCSUCCESS | | |
495 | MATCHING_PCUNSUCC | | |
496 | MATCHING_PMSUCCESS | | |
497 | MATCHING_PMUNSUCC | | |
498 | MATCHING_PROBLEM | | |
499 | MATCHING_TIMEOUT | | |
500 | MATCHING_UNQUALIFIED | | |
501 | PARALLEL_PORTCONN | | |
502 | PARALLEL_PORTMAP | | |
503 | PARALLEL_PTC | | |
504 | PARALLEL_UNQUALIFIED | | |
505 | PORTEVENT_DUALRECV | | |
506 | PORTEVENT_DUALSEND | | |
507 | PORTEVENT_MCRECV | | |
508 | PORTEVENT_MCSEND | | |
509 | PORTEVENT_MMRECV | | |
510 | PORTEVENT_MMSEND | | |
511 | PORTEVENT_MQUEUE | | |
512 | PORTEVENT_PCIN | | |
513 | PORTEVENT_PCOUT | | |
514 | PORTEVENT_PMIN | | |
515 | PORTEVENT_PMOUT | | |
516 | PORTEVENT_PQUEUE | | |
517 | PORTEVENT_STATE | | |
518 | PORTEVENT_UNQUALIFIED | | |
519 | STATISTICS_UNQUALIFIED | | |
520 | STATISTICS_VERDICT | | |
521 | TESTCASE_FINISH | | |
522 | TESTCASE_START | | |
523 | TESTCASE_UNQUALIFIED | | |
524 | TIMEROP_GUARD | | |
525 | TIMEROP_READ | | |
526 | TIMEROP_START | | |
527 | TIMEROP_STOP | | |
528 | TIMEROP_TIMEOUT | | |
529 | TIMEROP_UNQUALIFIED | | |
530 | USER_UNQUALIFIED | | |
531 | VERDICTOP_FINAL | | |
532 | VERDICTOP_GETVERDICT | | |
533 | VERDICTOP_SETVERDICT | | |
534 | VERDICTOP_UNQUALIFIED | | |
535 | WARNING_UNQUALIFIED RETURN(LoggingBit); | |
536 | ||
537 | [Tt][Ii][Mm][Ee] {yylval.ts_val=TSF_TIME; RETURN(TimestampValue);} | |
538 | [Dd][Aa][Tt][Ee][Tt][Ii][Mm][Ee] {yylval.ts_val=TSF_DATE_TIME; RETURN(TimestampValue);} | |
539 | [Ss][Ee][Cc][Oo][Nn][Dd][Ss] {yylval.ts_val=TSF_SEC; RETURN(TimestampValue);} | |
540 | ||
541 | [Nn][Oo][Nn][Ee] | | |
542 | [Ss][Ii][Nn][Gg][Ll][Ee] | | |
543 | [Ss][Tt][Aa][Cc][Kk] RETURN(SourceInfoValue); | |
544 | ||
545 | [Yy][Ee][Ss] | | |
546 | [Nn][Oo] RETURN(YesNo); | |
547 | ||
548 | [Dd]etailed RETURN(Detailed); | |
549 | [Cc]ompact RETURN(Compact); | |
550 | [Ss]ub[Cc]ategories RETURN(SubCategories); | |
551 | ||
552 | [Ee]rror RETURN(Error); | |
553 | ||
554 | [Ss]top RETURN(Stop); | |
555 | ||
556 | [Rr]etry RETURN(Re_try); | |
557 | ||
558 | [Dd]elete RETURN(Delete); | |
559 | } | |
560 | ||
af710487 | 561 | <SC_PROFILER> |
562 | { | |
563 | [Dd]isable[Pp]rofiler return DisableProfilerKeyword; | |
564 | [Dd]isable[Cc]overage return DisableCoverageKeyword; | |
565 | [Dd]ata[Bb]ase[Ff]ile return DatabaseFileKeyword; | |
566 | [Aa]ggregate[Dd]ata return AggregateDataKeyword; | |
567 | [Ss]tatistics[Ff]ile return StatisticsFileKeyword; | |
568 | [Dd]isable[Ss]tatistics return DisableStatisticsKeyword; | |
569 | } | |
570 | ||
970ed795 EL |
571 | <SC_EXECUTE>control RETURN(ControlKeyword); |
572 | ||
573 | <SC_EXTERNAL_COMMANDS> | |
574 | { | |
575 | [Bb]egin[Cc]ontrol[Pp]art RETURN(BeginControlPart); | |
576 | [Ee]nd[Cc]ontrol[Pp]art RETURN(EndControlPart); | |
577 | [Bb]egin[Tt]est[Cc]ase RETURN(BeginTestCase); | |
578 | [Ee]nd[Tt]est[Cc]ase RETURN(EndTestCase); | |
579 | } | |
580 | ||
581 | <SC_MAIN_CONTROLLER> | |
582 | { | |
583 | [Ll]ocal[Aa]ddress RETURN(LocalAddress); | |
584 | [Tt][Cc][Pp][Pp]ort RETURN(TCPPort); | |
585 | [Kk]ill[Tt]imer RETURN(KillTimer); | |
586 | [Nn]um[Hh][Cc]s RETURN(NumHCs); | |
587 | [Uu]nix[Ss]ockets[Ee]nabled RETURN(UnixSocketEnabled); | |
588 | [Yy][Ee][Ss] RETURN(YesToken); | |
589 | [Nn][Oo] RETURN(NoToken); | |
590 | } | |
591 | ||
592 | {TTCN3IDENTIFIER} { | |
593 | switch (YY_START) { | |
594 | case SC_GROUPS: | |
595 | case SC_COMPONENTS: | |
596 | case SC_EXECUTE: | |
597 | case SC_MAIN_CONTROLLER: | |
598 | yylval.str_val = (char*)Malloc(yyleng + 1); | |
599 | memcpy(yylval.str_val, yytext, yyleng + 1); | |
600 | break; | |
601 | default: | |
602 | yylval.str_val = NULL; | |
603 | } | |
604 | RETURN(Identifier); | |
605 | } | |
606 | ||
607 | <SC_MODULE_PARAMETERS>{ASN1LOWERIDENTIFIER} { | |
608 | char *ttcn3_id = (char*)Malloc(yyleng + 1); | |
609 | for (int i = 0; i < yyleng; i++) { | |
610 | if (yytext[i] == '-') ttcn3_id[i] = '_'; | |
611 | else ttcn3_id[i] = yytext[i]; | |
612 | } | |
613 | ttcn3_id[yyleng] = '\0'; | |
614 | config_read_warning("`%s' is not a valid TTCN-3 identifier. Did you mean " | |
615 | "`%s'?", yytext, ttcn3_id); | |
616 | cfg->config_read_buffer = mputprintf(cfg->config_read_buffer, "%s ", ttcn3_id); | |
617 | Free(ttcn3_id); | |
618 | return ASN1LowerIdentifier; | |
619 | } | |
620 | ||
621 | <SC_GROUPS,SC_COMPONENTS,SC_MAIN_CONTROLLER>{DNSNAME}|{IPV6} { | |
622 | yylval.str_val = (char*)Malloc(yyleng + 1); | |
623 | for (int i = 0; i < yyleng; i++) yylval.str_val[i] = tolower(yytext[i]); | |
624 | yylval.str_val[yyleng] = '\0'; | |
625 | RETURN(DNSName); | |
626 | } | |
627 | ||
628 | {MACRO_BOOL} { | |
629 | char *macroname = get_macro_id_from_ref(yytext); | |
630 | size_t macrolen; | |
631 | const char *macrovalue = | |
632 | string_map_get_bykey(config_defines, macroname, ¯olen); | |
633 | boolean bool_val; | |
634 | if (macrovalue != NULL) { | |
635 | if (!strcmp(macrovalue, "true")) bool_val = TRUE; | |
636 | else if (!strcmp(macrovalue, "false")) bool_val = FALSE; | |
637 | else { | |
638 | config_read_error("Macro `%s' cannot be interpreted as boolean value: " | |
639 | "`%s'", macroname, macrovalue); | |
640 | bool_val = FALSE; | |
641 | } | |
642 | } else { | |
643 | config_read_error("No macro or environmental variable defined with name " | |
644 | "`%s'", macroname); | |
645 | bool_val = FALSE; | |
646 | } | |
647 | Free(macroname); | |
648 | if (whether_update_buffer()) cfg->config_read_buffer = | |
649 | mputprintf(cfg->config_read_buffer, "%s ", bool_val ? "true" : "false"); | |
650 | return BooleanValue; | |
651 | } | |
652 | ||
653 | {MACRO_INT} { | |
654 | char *macroname = get_macro_id_from_ref(yytext); | |
655 | size_t macrolen = 0; | |
656 | BIGNUM *BN_0 = BN_new(); | |
657 | BN_set_word(BN_0, 0); | |
658 | const char *macrovalue = | |
659 | string_map_get_bykey(config_defines, macroname, ¯olen); | |
660 | if (macrovalue != NULL) { | |
661 | if (string_is_int(macrovalue, macrolen)) { | |
662 | yylval.int_val = NULL; | |
663 | BN_dec2bn(&yylval.int_val, | |
664 | *macrovalue == '+' ? macrovalue + 1 : macrovalue); | |
665 | } else { | |
666 | config_read_error("Macro `%s' cannot be interpreted as integer value: " | |
667 | "`%s'", macroname, macrovalue); | |
668 | yylval.int_val = BN_dup(BN_0); | |
669 | } | |
670 | } else { | |
671 | config_read_error("No macro or environmental variable defined with name " | |
672 | "`%s'", macroname); | |
673 | yylval.int_val = BN_dup(BN_0); | |
674 | } | |
675 | BN_free(BN_0); | |
676 | Free(macroname); | |
677 | char *int_val_str = BN_bn2dec(yylval.int_val); | |
678 | if (whether_update_buffer()) | |
679 | cfg->config_read_buffer = mputprintf(cfg->config_read_buffer, "%s ", int_val_str); | |
680 | OPENSSL_free(int_val_str); | |
681 | return Number; | |
682 | } | |
683 | ||
684 | {MACRO_FLOAT} { | |
685 | char *macroname = get_macro_id_from_ref(yytext); | |
686 | size_t macrolen; | |
687 | const char *macrovalue = | |
688 | string_map_get_bykey(config_defines, macroname, ¯olen); | |
689 | if (macrovalue != NULL) { | |
690 | if (string_is_float(macrovalue, macrolen)) | |
691 | yylval.float_val = atof(macrovalue); | |
692 | else { | |
693 | config_read_error("Macro `%s' cannot be interpreted as float value: " | |
694 | "`%s'", macroname, macrovalue); | |
695 | yylval.float_val = 0.0; | |
696 | } | |
697 | } else { | |
698 | config_read_error("No macro or environmental variable defined" | |
699 | " with name `%s'", macroname); | |
700 | yylval.float_val = 0.0; | |
701 | } | |
702 | Free(macroname); | |
703 | if (whether_update_buffer()) cfg->config_read_buffer = | |
704 | mputprintf(cfg->config_read_buffer, "%f ", yylval.float_val); | |
705 | return Float; | |
706 | } | |
707 | ||
708 | {MACRO_ID} { | |
709 | char *macroname = get_macro_id_from_ref(yytext); | |
710 | size_t macrolen; | |
711 | const char *macrovalue = | |
712 | string_map_get_bykey(config_defines, macroname, ¯olen); | |
713 | boolean is_asn = FALSE; | |
714 | if (macrovalue != NULL) { | |
715 | if (string_is_id(macrovalue, macrolen)) { | |
716 | yylval.str_val = mcopystr(macrovalue); | |
717 | for (size_t i = 0; i < macrolen; i++) { | |
718 | if (yylval.str_val[i] == '-') { | |
719 | is_asn = TRUE; | |
720 | yylval.str_val[i] = '_'; | |
721 | } | |
722 | } | |
723 | if (is_asn) config_read_warning("`%s' is not a valid TTCN-3 identifier. " | |
724 | "Did you mean `%s'?", macrovalue, yylval.str_val); | |
725 | if (whether_update_buffer()) cfg->config_read_buffer = | |
726 | mputprintf(cfg->config_read_buffer, "%s ", yylval.str_val); | |
727 | } else { | |
728 | config_read_error("Macro `%s' cannot be interpreted as identifier: `%s'", | |
729 | macroname, macrovalue); | |
730 | yylval.str_val = NULL; | |
731 | } | |
732 | } else { | |
733 | config_read_error("No macro or environmental variable defined with name " | |
734 | "`%s'", macroname); | |
735 | yylval.str_val = NULL; | |
736 | } | |
737 | Free(macroname); | |
738 | return Identifier; | |
739 | } | |
740 | ||
741 | {MACRO_CSTR} { | |
742 | char *macroname; | |
743 | if (yytext[1] == '{') macroname = get_macro_id_from_ref(yytext); | |
744 | else macroname = mcopystr(yytext + 1); | |
745 | size_t macrolen; | |
746 | const char *macrovalue = string_map_get_bykey | |
747 | (config_defines, macroname, ¯olen); | |
748 | if (macrovalue == NULL) { | |
749 | config_read_error("No macro or environmental variable defined with " | |
750 | "name `%s'", macroname); | |
751 | yylval.str_val = memptystr(); | |
752 | Free(macroname); | |
753 | return Cstring; | |
754 | } | |
755 | ||
756 | if (macrolen > 0 && macrovalue[0] == '{') { // structured | |
757 | main_buffer = YY_CURRENT_BUFFER; | |
758 | expansion_buffer = yy_scan_string(macrovalue); | |
759 | yy_switch_to_buffer(expansion_buffer); | |
760 | Free(macroname); | |
761 | } else { | |
762 | if (whether_update_buffer()) { | |
763 | cfg->config_read_buffer=mputc(cfg->config_read_buffer, '"'); | |
764 | for (size_t i = 0; i < macrolen; i++) { | |
765 | switch (macrovalue[i]) { | |
766 | case '"': | |
767 | cfg->config_read_buffer = mputstr(cfg->config_read_buffer, "\\\""); | |
768 | break; | |
769 | case '\\': | |
770 | cfg->config_read_buffer = mputstr(cfg->config_read_buffer, "\\\\"); | |
771 | break; | |
772 | case '\0': | |
773 | cfg->config_read_buffer = mputstr(cfg->config_read_buffer, "\\000"); | |
774 | break; | |
775 | default: | |
776 | cfg->config_read_buffer = mputc(cfg->config_read_buffer, macrovalue[i]); | |
777 | } /* switch */ | |
778 | } /* for */ | |
779 | cfg->config_read_buffer=mputstr(cfg->config_read_buffer, "\" "); | |
780 | } | |
781 | Free(macroname); | |
782 | yylval.str_val = mcopystr(macrovalue); | |
783 | return Cstring; | |
784 | } | |
785 | } | |
786 | ||
787 | {MACRO_BSTR} { | |
788 | char *macroname = get_macro_id_from_ref(yytext); | |
789 | size_t macrolen; | |
790 | const char *macrovalue = | |
791 | string_map_get_bykey(config_defines, macroname, ¯olen); | |
792 | if (macrovalue != NULL) { | |
793 | if (string_is_bstr(macrovalue, macrolen)) { | |
794 | if (whether_update_buffer()) cfg->config_read_buffer = | |
795 | mputprintf(cfg->config_read_buffer, "'%s'B ", macrovalue); | |
796 | } else config_read_error("Macro `%s' cannot be interpreted as bitstring " | |
797 | "value: `%s'", macroname, macrovalue); | |
798 | } else config_read_error("No macro or environmental variable defined with " | |
799 | "name `%s'", macroname); | |
800 | Free(macroname); | |
801 | return Bstring; | |
802 | } | |
803 | ||
804 | {MACRO_HSTR} { | |
805 | char *macroname = get_macro_id_from_ref(yytext); | |
806 | size_t macrolen; | |
807 | const char *macrovalue = | |
808 | string_map_get_bykey(config_defines, macroname, ¯olen); | |
809 | if (macrovalue != NULL) { | |
810 | if (string_is_hstr(macrovalue, macrolen)) { | |
811 | if (whether_update_buffer()) cfg->config_read_buffer = | |
812 | mputprintf(cfg->config_read_buffer, "'%s'H ", macrovalue); | |
813 | } else config_read_error("Macro `%s' cannot be interpreted as hexstring " | |
814 | "value: `%s'", macroname, macrovalue); | |
815 | } else config_read_error("No macro or environmental variable defined with " | |
816 | "name `%s'", macroname); | |
817 | Free(macroname); | |
818 | return Hstring; | |
819 | } | |
820 | ||
821 | {MACRO_OSTR} { | |
822 | char *macroname = get_macro_id_from_ref(yytext); | |
823 | size_t macrolen; | |
824 | const char *macrovalue = | |
825 | string_map_get_bykey(config_defines, macroname, ¯olen); | |
826 | if (macrovalue != NULL) { | |
827 | if (string_is_ostr(macrovalue, macrolen)) { | |
828 | if (whether_update_buffer()) cfg->config_read_buffer = | |
829 | mputprintf(cfg->config_read_buffer, "'%s'O ", macrovalue); | |
830 | } else config_read_error("Macro `%s' cannot be interpreted as octetstring " | |
831 | "value: `%s'", macroname, macrovalue); | |
832 | } else config_read_error("No macro or environmental variable defined with " | |
833 | "name `%s'", macroname); | |
834 | Free(macroname); | |
835 | return Ostring; | |
836 | } | |
837 | ||
838 | {MACRO_BINARY} { | |
839 | char *macroname = get_macro_id_from_ref(yytext); | |
840 | size_t macrolen; | |
841 | const char *macrovalue = | |
842 | string_map_get_bykey(config_defines, macroname, ¯olen); | |
843 | if (macrovalue != NULL) { | |
844 | if (whether_update_buffer()) { | |
845 | cfg->config_read_buffer = mputc(cfg->config_read_buffer, '\''); | |
846 | for (size_t i = 0; i < macrolen; i++) { | |
847 | cfg->config_read_buffer = mputprintf(cfg->config_read_buffer, "%02X", | |
848 | macrovalue[i]); | |
849 | } | |
850 | cfg->config_read_buffer = mputstr(cfg->config_read_buffer, "'O "); | |
851 | } | |
852 | } else config_read_error("No macro or environmental variable defined with " | |
853 | "name `%s'", macroname); | |
854 | Free(macroname); | |
855 | return Ostring; | |
856 | } | |
857 | ||
858 | {MACRO_HOSTNAME} { | |
859 | char *macroname = get_macro_id_from_ref(yytext); | |
860 | size_t macrolen; | |
861 | const char *macrovalue = | |
862 | string_map_get_bykey(config_defines, macroname, ¯olen); | |
863 | if (macrovalue != NULL) { | |
864 | if (string_is_hostname(macrovalue, macrolen)) { | |
865 | if (whether_update_buffer()) { | |
866 | for (size_t i = 0; i < macrolen; i++) { | |
867 | cfg->config_read_buffer = | |
868 | mputc(cfg->config_read_buffer, tolower(macrovalue[i])); | |
869 | } | |
870 | yylval.str_val = NULL; | |
871 | } else { | |
872 | yylval.str_val = (char*)Malloc(macrolen + 1); | |
873 | for (size_t i = 0; i < macrolen; i++) | |
874 | yylval.str_val[i] = tolower(macrovalue[i]); | |
875 | yylval.str_val[macrolen] = '\0'; | |
876 | } | |
877 | } else { | |
878 | config_read_error("Macro `%s' cannot be interpreted as host name: " | |
879 | "`%s'", macroname, macrovalue); | |
880 | yylval.str_val = NULL; | |
881 | } | |
882 | } else { | |
883 | config_read_error("No macro or environmental variable defined with " | |
884 | "name `%s'", macroname); | |
885 | yylval.str_val = NULL; | |
886 | } | |
887 | Free(macroname); | |
888 | return DNSName; | |
889 | } | |
890 | ||
891 | ":="|"=" RETURN(AssignmentChar); | |
892 | "&=" RETURN(ConcatChar); | |
893 | ||
894 | . RETURN(yytext[0]); | |
895 | ||
896 | <*><<EOF>> { | |
897 | if (expansion_buffer) { | |
898 | yy_switch_to_buffer(main_buffer); | |
899 | yy_delete_buffer(expansion_buffer); | |
900 | expansion_buffer = NULL; | |
901 | } else { | |
902 | if (YY_START == SC_blockcomment) { | |
903 | config_read_error("Unterminated block " | |
904 | "comment (missing */ at the end of file)."); | |
905 | return EOF; | |
906 | } else { | |
907 | if (include_chain->size() > 1) { | |
908 | yy_delete_buffer(YY_CURRENT_BUFFER); | |
909 | fclose(include_chain->back().fp); | |
910 | include_chain->pop_back(); | |
911 | yy_switch_to_buffer(include_chain->back().buffer_state); | |
912 | yylineno = include_chain->back().line_number; | |
913 | BEGIN(SC_ORDERED_INCLUDE); | |
914 | } else { | |
915 | return EOF; | |
916 | } | |
917 | } | |
918 | } | |
919 | } | |
920 | ||
921 | %% | |
922 | ||
923 | static void update_buffer() | |
924 | { | |
925 | if (whether_update_buffer()) { | |
926 | cfg->config_read_buffer = mputstr(cfg->config_read_buffer, yytext); | |
927 | cfg->config_read_buffer = mputc (cfg->config_read_buffer, ' '); | |
928 | } | |
929 | } | |
930 | ||
931 | static boolean whether_update_buffer() | |
932 | { | |
933 | switch (YY_START) { | |
934 | case SC_MODULE_PARAMETERS: | |
935 | case SC_LOGGING: | |
936 | case SC_TESTPORT_PARAMETERS: | |
937 | case SC_EXTERNAL_COMMANDS: | |
938 | return TRUE; | |
939 | default: | |
940 | return FALSE; | |
941 | } /* switch */ | |
942 | } | |
943 | ||
944 | void config_read_reset(const char* current_filename_) { | |
945 | if (!include_chain) { | |
946 | include_chain = new std::deque<IncludeElem<YY_BUFFER_STATE> >(); | |
947 | } | |
948 | ||
949 | include_chain->clear(); | |
950 | include_chain->push_back( | |
951 | IncludeElem<YY_BUFFER_STATE>(std::string(current_filename_), config_read_in)); | |
952 | } | |
953 | ||
954 | void config_read_close() { | |
955 | delete include_chain; | |
956 | include_chain = NULL; | |
957 | } | |
958 |