Commit | Line | Data |
---|---|---|
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 | ||
9 | %option noyywrap | |
10 | %option yylineno | |
11 | %option nounput | |
12 | %{ | |
13 | ||
14 | /* | |
15 | ||
16 | Tokenizer source code for TTCN-3 (input of flex) | |
17 | Rev: PA10 | |
18 | Date: April 15 2005 | |
19 | Author: Janos Zoltan Szabo (ejnosza) | |
20 | ||
21 | Revision history: | |
22 | ||
23 | Rev. Date Author Comments | |
24 | PA1 Nov 10 2000 tmpjsz Created from the prototype compiler. | |
25 | PA2 Dec 5 2000 tmpjsz Obsolete keywords removed. | |
26 | Updated according to BNF v1.0.10. | |
27 | PA3 Dec 11 2000 tmpjsz No changes. | |
28 | ||
29 | PA5 Sep 20 2001 tmpjsz Updated according to BNF v1.1.2. | |
30 | PA6 Apr 16-17 2002 tmpjsz Upgrade to BNF v2.2.0 (Rev. 12.5) | |
31 | PA7 Nov 26-27 2002 tmpjsz Upgrade to BNF v2.2.1 (Rev. 12.7) | |
32 | PA8 May 10-13 2004 ejnosza Upgrade to BNF v3.0.0Mockupv1 | |
33 | PA9 March 2005 ejnosza Added support for multi-dimension | |
34 | sub-references in port/timer/component | |
35 | operations. | |
36 | PA10 Apr 13-15 2005 ejnosza Upgrade to final BNF v3.0.0 | |
37 | ||
38 | */ | |
39 | ||
40 | #include "parser.tab.h" | |
41 | ||
42 | int dot_flag = 0; | |
43 | ||
44 | #define RETURN(ret_val) \ | |
45 | if (dot_flag) { \ | |
46 | backup_token = ret_val; \ | |
47 | return '.'; \ | |
48 | } else return ret_val | |
49 | ||
50 | #define RETURN_DOT(ret_val) \ | |
51 | if (dot_flag) { \ | |
52 | dot_flag = 0; \ | |
53 | return Dot##ret_val; \ | |
54 | } else return ret_val | |
55 | ||
56 | %} | |
57 | ||
58 | BIN 0|1 | |
59 | BINORMATCH {BIN}|"\?"|"\*" | |
60 | HEX [0-9A-Fa-f] | |
61 | HEXORMATCH {HEX}|"\?"|"\*" | |
62 | OCT {HEX}{HEX} | |
63 | OCTORMATCH {OCT}|"\?"|"\*" | |
64 | CHAR [^\"] | |
65 | ||
66 | NUMBER 0|([1-9][0-9]*) | |
67 | ||
68 | FLOAT ({NUMBER}\.[0-9]+)|({NUMBER}(\.[0-9]+)?E-?{NUMBER}) | |
69 | ||
70 | IDENTIFIER [A-Za-z][A-Za-z0-9_]* | |
71 | ||
72 | COMMENT \/\*[^\*]*(\*+[^\/\*][^\*]*)*\*+\/ | |
73 | CPLUSPLUSCOMMENT \/\/[^\r\n]* | |
74 | ||
75 | WHITESPACE [ \t\r\n]+ | |
76 | ||
77 | %% | |
78 | static int backup_token; | |
79 | if (dot_flag) { | |
80 | dot_flag = 0; | |
81 | return backup_token; | |
82 | } | |
83 | ||
84 | {WHITESPACE} { /* Drop whitespaces */ } | |
85 | ||
86 | {COMMENT}|{CPLUSPLUSCOMMENT} { /* Drop comments */ } | |
87 | ||
88 | /* Keywords */ | |
89 | ||
90 | action RETURN(ActionKeyword); | |
91 | activate RETURN(ActivateKeyword); | |
92 | address RETURN(AddressKeyword); | |
93 | alive RETURN_DOT(AliveKeyword); | |
94 | all RETURN(AllKeyword); | |
95 | alt RETURN(AltKeyword); | |
96 | altstep RETURN(AltstepKeyword); | |
97 | any RETURN(AnyKeyword); | |
98 | anytype RETURN(AnyTypeKeyword); | |
99 | bitstring RETURN(BitStringKeyword); | |
100 | boolean RETURN(BooleanKeyword); | |
101 | call RETURN_DOT(CallOpKeyword); | |
102 | case RETURN(CaseKeyword); | |
103 | catch RETURN_DOT(CatchOpKeyword); | |
104 | char RETURN(CharKeyword); | |
105 | charstring RETURN(CharStringKeyword); | |
106 | check RETURN_DOT(CheckOpKeyword); | |
107 | clear RETURN_DOT(ClearOpKeyword); | |
108 | complement RETURN(ComplementKeyword); | |
109 | component RETURN(ComponentKeyword); | |
110 | connect RETURN(ConnectKeyword); | |
111 | const RETURN(ConstKeyword); | |
112 | control RETURN(ControlKeyword); | |
113 | create RETURN_DOT(CreateKeyword); | |
114 | default RETURN(DefaultKeyword); | |
115 | deactivate RETURN(DeactivateKeyword); | |
116 | disconnect RETURN(DisconnectKeyword); | |
117 | display RETURN(DisplayKeyword); | |
118 | do RETURN(DoKeyword); | |
119 | done RETURN_DOT(DoneKeyword); | |
120 | else RETURN(ElseKeyword); | |
121 | encode RETURN(EncodeKeyword); | |
122 | enumerated RETURN(EnumKeyword); | |
123 | except RETURN(ExceptKeyword); | |
124 | exception RETURN(ExceptionKeyword); | |
125 | execute RETURN(ExecuteKeyword); | |
126 | extends RETURN(ExtendsKeyword); | |
127 | extension RETURN(ExtensionKeyword); | |
128 | external RETURN(ExtKeyword); | |
129 | float RETURN(FloatKeyword); | |
130 | for RETURN(ForKeyword); | |
131 | from RETURN(FromKeyword); | |
132 | function RETURN(FunctionKeyword); | |
133 | getcall RETURN_DOT(GetCallOpKeyword); | |
134 | getreply RETURN_DOT(GetReplyOpKeyword); | |
135 | getverdict RETURN(GetVerdictKeyword); | |
136 | goto RETURN(GotoKeyword); | |
137 | group RETURN(GroupKeyword); | |
138 | hexstring RETURN(HexStringKeyword); | |
139 | if RETURN(IfKeyword); | |
140 | ifpresent RETURN(IfPresentKeyword); | |
141 | import RETURN(ImportKeyword); | |
142 | in RETURN(InParKeyword); | |
143 | infinity RETURN(InfinityKeyword); | |
144 | inout RETURN(InOutParKeyword); | |
145 | integer RETURN(IntegerKeyword); | |
146 | interleave RETURN(InterleavedKeyword); | |
147 | kill RETURN_DOT(KillKeyword); | |
148 | killed RETURN_DOT(KilledKeyword); | |
149 | label RETURN(LabelKeyword); | |
150 | language RETURN(LanguageKeyword); | |
151 | length RETURN(LengthKeyword); | |
152 | log RETURN(LogKeyword); | |
153 | map RETURN(MapKeyword); | |
154 | match RETURN(MatchKeyword); | |
155 | message RETURN(MessageKeyword); | |
156 | mixed RETURN(MixedKeyword); | |
157 | modifies RETURN(ModifiesKeyword); | |
158 | module RETURN(TTCN3ModuleKeyword); | |
159 | modulepar RETURN(ModuleParKeyword); | |
160 | mtc RETURN(MTCKeyword); | |
161 | noblock RETURN(NoBlockKeyword); | |
162 | nowait RETURN(NowaitKeyword); | |
163 | objid RETURN(ObjectIdentifierKeyword); | |
164 | octetstring RETURN(OctetStringKeyword); | |
165 | of RETURN(OfKeyword); | |
166 | omit RETURN(OmitKeyword); | |
167 | on RETURN(OnKeyword); | |
168 | optional RETURN(OptionalKeyword); | |
169 | out RETURN(OutParKeyword); | |
170 | override RETURN(OverrideKeyword); | |
171 | param RETURN(ParamKeyword); | |
172 | pattern RETURN(PatternKeyword); | |
173 | permutation RETURN(PermutationKeyword); | |
174 | port RETURN(PortKeyword); | |
175 | procedure RETURN(ProcedureKeyword); | |
176 | raise RETURN_DOT(RaiseKeyword); | |
177 | read RETURN_DOT(ReadKeyword); | |
178 | receive RETURN_DOT(ReceiveOpKeyword); | |
179 | record RETURN(RecordKeyword); | |
180 | recursive RETURN(RecursiveKeyword); | |
181 | reply RETURN_DOT(ReplyKeyword); | |
182 | repeat RETURN(RepeatKeyword); | |
183 | return RETURN(ReturnKeyword); | |
184 | running RETURN_DOT(RunningKeyword); | |
185 | runs RETURN(RunsKeyword); | |
186 | select RETURN(SelectKeyword); | |
187 | self RETURN(SelfOp); | |
188 | send RETURN_DOT(SendOpKeyword); | |
189 | sender RETURN(SenderKeyword); | |
190 | set RETURN(SetKeyword); | |
191 | setverdict RETURN(SetVerdictKeyword); | |
192 | signature RETURN(SignatureKeyword); | |
193 | start RETURN_DOT(StartKeyword); | |
194 | stop RETURN_DOT(StopKeyword); | |
195 | subset RETURN(SubsetKeyword); | |
196 | superset RETURN(SupersetKeyword); | |
197 | system RETURN(SystemKeyword); | |
198 | template RETURN(TemplateKeyword); | |
199 | testcase RETURN(TestcaseKeyword); | |
200 | timeout RETURN_DOT(TimeoutKeyword); | |
201 | timer RETURN(TimerKeyword); | |
202 | to RETURN(ToKeyword); | |
203 | trigger RETURN_DOT(TriggerOpKeyword); | |
204 | type RETURN(TypeDefKeyword); | |
205 | union RETURN(UnionKeyword); | |
206 | universal RETURN(UniversalKeyword); | |
207 | unmap RETURN(UnmapKeyword); | |
208 | value RETURN(ValueKeyword); | |
209 | valueof RETURN(ValueofKeyword); | |
210 | var RETURN(VarKeyword); | |
211 | variant RETURN(VariantKeyword); | |
212 | verdicttype RETURN(VerdictTypeKeyword); | |
213 | while RETURN(WhileKeyword); | |
214 | with RETURN(WithKeyword); | |
215 | ||
216 | /* Values */ | |
217 | ||
218 | {NUMBER} RETURN(Number); | |
219 | ||
220 | {FLOAT} RETURN(FloatValue); | |
221 | ||
222 | true|false RETURN(BooleanConst); | |
223 | ||
224 | pass|fail|inconc|none|error RETURN(VerdictConst); | |
225 | ||
226 | \'{BIN}*\'B RETURN(Bstring); | |
227 | ||
228 | \'{BINORMATCH}*\'B RETURN(BitStringMatch); | |
229 | ||
230 | \'{HEX}*\'H RETURN(Hstring); | |
231 | ||
232 | \'{HEXORMATCH}*\'H RETURN(HexStringMatch); | |
233 | ||
234 | \'{OCT}*\'O RETURN(Ostring); | |
235 | ||
236 | \'{OCTORMATCH}*\'O RETURN(OctetStringMatch); | |
237 | ||
238 | (\"{CHAR}*\"|"<\">")+ RETURN(Cstring); | |
239 | ||
240 | null RETURN(NullKeyword); | |
241 | ||
242 | /* Multi-character operators */ | |
243 | ||
244 | ":=" RETURN(AssignmentChar); | |
245 | ".." RETURN(DotDot); | |
246 | "->" RETURN(PortRedirectSymbol); | |
247 | "==" RETURN(EQ); | |
248 | "!=" RETURN(NE); | |
249 | ">=" RETURN(GE); | |
250 | "<=" RETURN(LE); | |
251 | ||
252 | "<<" RETURN(SL); | |
253 | ">>" RETURN(SR); | |
254 | "<@" RETURN(RL); | |
255 | "@>" RETURN(RR); | |
256 | ||
257 | mod RETURN(Mod); | |
258 | rem RETURN(Rem); | |
259 | or RETURN(Or); | |
260 | or4b RETURN(Or4b); | |
261 | xor RETURN(Xor); | |
262 | xor4b RETURN(Xor4b); | |
263 | and RETURN(And); | |
264 | and4b RETURN(And4b); | |
265 | not RETURN(Not); | |
266 | not4b RETURN(Not4b); | |
267 | ||
268 | /* Identifiers */ | |
269 | ||
270 | {IDENTIFIER} RETURN(Identifier); | |
271 | ||
272 | /* Single character literals */ | |
273 | ||
274 | \. if (dot_flag) { | |
275 | backup_token = '.'; | |
276 | return '.'; | |
277 | } else dot_flag = 1; | |
278 | ||
279 | . return yytext[0]; | |
280 | ||
281 | <<EOF>> if (dot_flag) { | |
282 | dot_flag = 0; | |
283 | return '.'; | |
284 | } else return EOF; | |
285 | ||
286 | %% | |
287 |