1 : %{
2 : //==============================================================================
3 : // File <$/src/cpp/dev/idlc/idl_flex.ll>
4 : // This file is part of YaOrb : Yet Another Object Request Broker,
5 : // Copyright (c) 2000-2003, 2006, Marc Alff.
6 : //
7 : // This program is free software; you can redistribute it and/or
8 : // modify it under the terms of the GNU General Public License
9 : // as published by the Free Software Foundation; either version 2
10 : // of the License, or (at your option) any later version.
11 : //
12 : // This program is distributed in the hope that it will be useful,
13 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : // GNU General Public License for more details.
16 : //
17 : // You should have received a copy of the GNU General Public License
18 : // along with this program; if not, write to the Free Software
19 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20 : //
21 : //==============================================================================
22 :
23 : // Generated by flex as File <$/src/cpp/dev/idlc/idl_flex.cc>
24 :
25 : /* Definitions */
26 :
27 : /*
28 : * _GNU_SOURCE is used for strtold in stdlib.h
29 : * #define _GNU_SOURCE is done in the Makefile and can not be done here
30 : * because flex generate his own headers (so #define _GNU_SOURCE will
31 : * be found too late in lex.c)
32 : */
33 :
34 : // Portability
35 : #include "yaorb/config.h"
36 : #include "src/cpp/prod/port/port_stdc.h"
37 : #include "src/cpp/prod/port/port_stdlib.h"
38 :
39 : #ifdef HAVE_STRTOLD
40 : #define BEST_FLOAT_TYPE long double
41 : #define BEST_FLOAT_PARSE strtold
42 : #define BEST_FLOAT_PUT PutF96
43 : #else
44 : #ifdef HAVE_STRTOD
45 : #warning "not using long double, using double instead."
46 :
47 : #define BEST_FLOAT_TYPE double
48 : #define BEST_FLOAT_PARSE strtod
49 : #define BEST_FLOAT_PUT PutF64
50 : #else
51 : #ifdef HAVE_STRTOF
52 : #warning "not using long double or double, using float instead."
53 :
54 : #define BEST_FLOAT_TYPE float
55 : #define BEST_FLOAT_PARSE strtof
56 : #define BEST_FLOAT_PUT PutF32
57 : #else
58 : #error "You don't really need foats, do you ?"
59 : #endif
60 : #endif
61 : #endif
62 :
63 : #include <stdio.h>
64 : #include <iostream>
65 : #include <ctype.h>
66 : #include <errno.h>
67 :
68 : #include <yaorb/platform.h>
69 :
70 : #include "src/cpp/prod/tool/DEVELOPMENT.h"
71 : #include "src/cpp/prod/tool/String.h"
72 : #include "src/cpp/prod/tool/WString.h"
73 : #include "src/cpp/prod/tool/Assert.h"
74 :
75 : class IDLConstExp ;
76 : class IDLType ;
77 : class Scope ;
78 : class Member ;
79 : class Module ;
80 :
81 : #include "src/cpp/dev/idlc/all_symbols.h"
82 : #include "src/cpp/dev/idlc/yyutils.h"
83 : #include "src/cpp/dev/idlc/idl_type.h"
84 : #include "src/cpp/dev/idlc/idl_bison.h"
85 : #include "src/cpp/dev/idlc/value.h"
86 : #include "src/cpp/dev/idlc/int_value.h"
87 : #include "src/cpp/dev/idlc/float_value.h"
88 : #include "src/cpp/dev/idlc/char_value.h"
89 : #include "src/cpp/dev/idlc/wchar_value.h"
90 : #include "src/cpp/dev/idlc/const_exp.h"
91 : #include "src/cpp/dev/idlc/sym_tab.h"
92 : #include "src/cpp/dev/idlc/define.h"
93 :
94 : static int nb_char ;
95 : static unsigned char current_char ;
96 : static wchar_t current_wchar ;
97 63 : static String current_string(132) ;
98 63 : static WString current_wstring(132) ;
99 :
100 : // See Flex man page for #includes handling ...
101 :
102 : enum IfdefInfo
103 : {
104 : before_activation,
105 : during_activation,
106 : after_activation
107 : } ;
108 :
109 : struct LexIncludeInfo
110 756 : {
111 : YY_BUFFER_STATE _buffer ;
112 : String _fileName ;
113 : String _fileFullName ;
114 : int _lineNumber ;
115 : String _prefix ;
116 : } ;
117 :
118 : const int IDL_MAX_INCLUDE_DEPTH = 12 ;
119 756 : static struct LexIncludeInfo includeStack[IDL_MAX_INCLUDE_DEPTH] ;
120 : static int includeStackIndex = -1 ;
121 :
122 : const int IDL_MAX_IFDEF_DEPTH = 12 ;
123 : static enum IfdefInfo ifdefInfoStack[IDL_MAX_IFDEF_DEPTH] ;
124 : static int ifdefStackIndex = -1 ;
125 :
126 : static int silentNestedIfdef = 0 ;
127 :
128 0 : void DumpIncludeStack(std::ostream& str)
129 : {
130 0 : NON_DEV("DumpIncludeStack") ;
131 : }
132 :
133 :
134 : // TO DO
135 : // { return fixed_pt_literal ; }
136 :
137 :
138 :
139 : //=============================================================================
140 : // MASTER AUTOMATON
141 : //
142 : // Start Node : INITIAL
143 : //
144 : // INITIAL <==> c_comment
145 : // <==> cpp_comment
146 : // <==> character
147 : // <==> wcharacter
148 : // <==> string
149 : // <==> wstring
150 : // ---> preprocessor ---> INITIAL (#error and #line)
151 : // ---> pragma ---> INITIAL (#pragma)
152 : // ---> include ---> INITIAL (#include)
153 : // ---> define ---> INITIAL (#define)
154 : // ---> undef ---> INITIAL (#undef)
155 : // ---> if ---> INITIAL (#if is true)
156 : // ---> silent (#if is false)
157 : // ---> ifdef ---> INITIAL (#ifdef is true)
158 : // ---> silent (#ifdef is false)
159 : // ---> ifndef ---> INITIAL (#ifndef is true)
160 : // ---> silent (#ifndef is false)
161 : // ---> else ---> INITIAL (#else is true)
162 : // ---> silent (#else is false)
163 : // ---> elseif ---> INITIAL (#elseif is true)
164 : // ---> silent (#elseif is false)
165 : // ---> INITIAL (#endif)
166 : //
167 : // silent --> INITIAL (closing #else or #endif found)
168 : // silent --> elif (closing #elif found)
169 : //
170 : //=============================================================================
171 :
172 : %}
173 :
174 : %x c_comment cpp_comment character wcharacter string wstring preprocessor _pragma _include _if _ifdef _ifndef _define _elif silent
175 :
176 : space [ \t]+
177 : CR [\n]|[\n\r]
178 : alpha [a-zA-Z_]
179 : alnum [a-zA-Z_0-9]
180 : identifier {alpha}{alnum}*
181 :
182 : integer8 [0][0-7]*
183 : integer10 [1-9][0-9]*
184 : integer16 [0][xX][0-9A-Fa-f]+
185 : integer {integer8}|{integer10}|{integer16}
186 : digits [0-9]+
187 : exponent [eE][+-]?{digits}
188 :
189 : float1 {digits}("."{digits})?{exponent}
190 : float2 "."{digits}{exponent}?
191 : float3 {digits}"."{digits}
192 : float {float1}|{float2}|{float3}
193 :
194 : quoted_string "\"".*"\""
195 :
196 : user_file "\""[^\"]*"\""
197 : system_file "<"[^>]*">"
198 :
199 : pragma_string "\"".*"\""
200 : pragma_name ({identifier}|"::")+
201 : pragma_version {digits}"."{digits}
202 :
203 : backslash "\\"|"??/"
204 :
205 : %%
206 :
207 : <INITIAL>{
208 :
209 1 : "??=" { unput('#') ; break ; }
210 1 : "??(" { unput('[') ; break ; }
211 1 : "??)" { unput(']') ; break ; }
212 2 : "??<" { unput('{') ; break ; }
213 2 : "??>" { unput('}') ; break ; }
214 0 : "??/" { unput('\\') ; break ; }
215 1 : "??'" { unput('^') ; break ; }
216 0 : "??!" { unput('|') ; break ; }
217 1 : "??-" { unput('~') ; break ; }
218 :
219 44249 : {space} { if (g_echo) { ECHO; } break ; }
220 25449 : {CR} { if (g_echo) { ECHO; } IDLLineNumber++ ; break ; }
221 :
222 119 : "/*" { BEGIN(c_comment) ; break ; }
223 1448 : "//" { BEGIN(cpp_comment) ; break ; }
224 67 : "'" { if (g_echo) { ECHO; } BEGIN(character) ;
225 67 : nb_char = 0 ; current_char = '\0' ; break ; }
226 24 : "\"" { if (g_echo) { ECHO; } BEGIN(string) ;
227 24 : current_string = "" ; break ; }
228 55 : "L'" { if (g_echo) { ECHO; } BEGIN(wcharacter) ;
229 55 : nb_char = 0 ; current_wchar = L'\0' ; break ; }
230 10 : "L\"" { if (g_echo) { ECHO; } BEGIN(wstring) ;
231 10 : current_wstring = L"" ; break ; }
232 1073 : "#" { BEGIN(preprocessor) ; break ; }
233 :
234 489 : "::" { if (g_echo) { ECHO; } return TOK_DOUBLE_SEMICOLON ; }
235 60 : "<<" { if (g_echo) { ECHO; } return TOK_SHIFT_LEFT ; }
236 9 : ">>" { if (g_echo) { ECHO; } return TOK_SHIFT_RIGHT ; }
237 :
238 8365 : ";" { if (g_echo) { ECHO; } return TOK_SEMICOLON ; }
239 1783 : "{" { if (g_echo) { ECHO; } return TOK_LEFT_CURLY_BRAKET ; }
240 1783 : "}" { if (g_echo) { ECHO; } return TOK_RIGHT_CURLY_BRAKET ; }
241 530 : ":" { if (g_echo) { ECHO; } return TOK_COLON ; }
242 3938 : "," { if (g_echo) { ECHO; } return TOK_COMMA ; }
243 621 : "=" { if (g_echo) { ECHO; } return TOK_EQUALS ; }
244 37 : "+" { if (g_echo) { ECHO; } return TOK_PLUS ; }
245 97 : "-" { if (g_echo) { ECHO; } return TOK_MINUS ; }
246 2815 : "(" { if (g_echo) { ECHO; } return TOK_LEFT_PARENTHESIS ; }
247 2815 : ")" { if (g_echo) { ECHO; } return TOK_RIGHT_PARENTHESIS ; }
248 390 : "<" { if (g_echo) { ECHO; } return TOK_LESS_THAN ; }
249 390 : ">" { if (g_echo) { ECHO; } return TOK_GREATER_THAN ; }
250 3 : "[" { if (g_echo) { ECHO; } return TOK_LEFT_SQUARE_BRAKET ; }
251 3 : "]" { if (g_echo) { ECHO; } return TOK_RIGHT_SQUARE_BRAKET ; }
252 9 : "|" { if (g_echo) { ECHO; } return TOK_VERTICAL_LINE ; }
253 10 : "^" { if (g_echo) { ECHO; } return TOK_CIRCUMFLEX ; }
254 9 : "&" { if (g_echo) { ECHO; } return TOK_AMPERSAND ; }
255 12 : "*" { if (g_echo) { ECHO; } return TOK_ASTERISK ; }
256 12 : "/" { if (g_echo) { ECHO; } return TOK_SOLIDUS ; }
257 9 : "%" { if (g_echo) { ECHO; } return TOK_PERCENT ; }
258 10 : "~" { if (g_echo) { ECHO; } return TOK_TILDE ; }
259 :
260 : {identifier} {
261 : // Build a string with the identifier name
262 35824 : char * text = yytext ;
263 35824 : int token = TokenType(text) ;
264 35824 : if (g_echo) { ECHO; }
265 35824 : if (token == TOK_IDENTIFIER)
266 : {
267 22729 : if (CollideKeyword(text))
268 : {
269 0 : yyerror("identifier collide with keyword") ;
270 : }
271 22729 : if (*text == '_')
272 : {
273 : // CORBA 2.3 : _ is used as escape !
274 22 : text++ ;
275 22 : if (*text == '\0')
276 : {
277 1 : yyerror("identifier '_' escapes to an empty string") ;
278 : }
279 : }
280 22729 : yylval.StringPtr = new String(text) ;
281 : }
282 : return token ; }
283 :
284 : {float} {
285 : BEST_FLOAT_TYPE v ;
286 27 : char *tmp = NULL ;
287 27 : const char* text = yytext ;
288 : bool failed = false ;
289 27 : if (g_echo) { ECHO; }
290 27 : errno = 0 ;
291 : v = BEST_FLOAT_PARSE(text, & tmp) ;
292 27 : if (errno)
293 : {
294 0 : errno = 0 ;
295 : failed = true ;
296 : }
297 27 : if (tmp != NULL)
298 : {
299 27 : if (*tmp != '\0')
300 : {
301 : failed = true ;
302 : }
303 : }
304 : else
305 : {
306 : failed = true ;
307 : }
308 27 : IDLFloatValue *value = new IDLFloatValue() ;
309 27 : value->BEST_FLOAT_PUT(v) ;
310 27 : if (failed)
311 : {
312 0 : yyerror("Error reading a float/double/long double") ;
313 0 : value->SetError() ;
314 : }
315 27 : IDLConstExp *exp = new IDLValueExp(value) ;
316 27 : yylval.ConstExpPtr = exp ;
317 27 : return floating_pt_literal ; }
318 :
319 : {integer} {
320 : uint64_t v;
321 514 : char *tmp = NULL ;
322 514 : const char* text = yytext ;
323 : bool failed = false ;
324 514 : if (g_echo) { ECHO; }
325 514 : errno = 0 ;
326 : v = strtoull(text, & tmp, 0) ;
327 514 : if (errno)
328 : {
329 3 : errno = 0 ;
330 : failed = true ;
331 : }
332 514 : if (tmp != NULL)
333 : {
334 514 : if (*tmp != '\0')
335 : {
336 : failed = true ;
337 : }
338 : }
339 : else
340 : {
341 : failed = true ;
342 : }
343 514 : IDLIntValue *value = new IDLIntValue() ;
344 514 : value->PutU64(v) ;
345 514 : if (failed)
346 : {
347 3 : yyerror("Error reading an integer") ;
348 3 : value->SetError() ;
349 : }
350 514 : IDLConstExp *exp = new IDLValueExp(value) ;
351 514 : yylval.ConstExpPtr = exp ;
352 514 : return integer_literal ; }
353 :
354 0 : . { yyerror("Uknown token") ; break ; }
355 :
356 : <<EOF>> {
357 145 : if (includeStackIndex >= 0)
358 : {
359 82 : yy_delete_buffer( YY_CURRENT_BUFFER ) ;
360 82 : yy_switch_to_buffer(includeStack[includeStackIndex]._buffer) ;
361 82 : IDLFileName = includeStack[includeStackIndex]._fileName ;
362 82 : IDLLineNumber = includeStack[includeStackIndex]._lineNumber ;
363 82 : g_symTabPtr->SetPrefix(includeStack[includeStackIndex]._prefix) ;
364 82 : includeStackIndex -- ;
365 : }
366 : else
367 : {
368 : yyterminate() ;
369 : }
370 : }
371 : }
372 :
373 : <c_comment>{
374 : "*/" {
375 201 : BEGIN(INITIAL) ;
376 201 : break ; }
377 : {CR} {
378 5 : IDLLineNumber++ ;
379 5 : break ; }
380 : . { break ; }
381 : }
382 :
383 : <cpp_comment>{
384 : {CR} {
385 1448 : IDLLineNumber++ ;
386 1448 : BEGIN(INITIAL) ;
387 1448 : break ; }
388 : . { break ; }
389 : }
390 :
391 : <character>{
392 : "??=" {
393 1 : unput('#') ;
394 1 : break ; }
395 : "??(" {
396 1 : unput('[') ;
397 1 : break ; }
398 : "??)" {
399 1 : unput(']') ;
400 1 : break ; }
401 : "??<" {
402 1 : unput('{') ;
403 1 : break ; }
404 : "??>" {
405 1 : unput('}') ;
406 1 : break ; }
407 : "??/" {
408 2 : unput('\\') ;
409 2 : break ; }
410 : "\\??/" {
411 1 : unput('\\') ;
412 1 : unput('\\') ;
413 1 : break ; }
414 : "??'" {
415 1 : unput('^') ;
416 1 : break ; }
417 : "??!" {
418 1 : unput('|') ;
419 1 : break ; }
420 : "??-" {
421 1 : unput('~') ;
422 1 : break ; }
423 :
424 : "\\n" {
425 2 : if (g_echo) { ECHO; }
426 2 : current_char = '\n' ;
427 2 : nb_char++ ;
428 2 : break ; }
429 : "\\t" {
430 1 : if (g_echo) { ECHO; }
431 1 : current_char = '\t' ;
432 1 : nb_char++ ;
433 1 : break ; }
434 : "\\v" {
435 1 : if (g_echo) { ECHO; }
436 1 : current_char = '\v' ;
437 1 : nb_char++ ;
438 1 : break ; }
439 : "\\b" {
440 1 : if (g_echo) { ECHO; }
441 1 : current_char = '\b' ;
442 1 : nb_char++ ;
443 1 : break ; }
444 : "\\r" {
445 1 : if (g_echo) { ECHO; }
446 1 : current_char = '\r' ;
447 1 : nb_char++ ;
448 1 : break ; }
449 : "\\f" {
450 2 : if (g_echo) { ECHO; }
451 2 : current_char = '\f' ;
452 2 : nb_char++ ;
453 2 : break ; }
454 : "\\a" {
455 1 : if (g_echo) { ECHO; }
456 1 : current_char = '\a' ;
457 1 : nb_char++ ;
458 1 : break ; }
459 : "\\\\" {
460 2 : if (g_echo) { ECHO; }
461 2 : current_char = '\\' ;
462 2 : nb_char++ ;
463 2 : break ; }
464 : "\\'" {
465 1 : if (g_echo) { ECHO; }
466 1 : current_char = '\'' ;
467 1 : nb_char++ ;
468 1 : break ; }
469 :
470 : "\\"[0-7]{1,3} {
471 7 : unsigned int octal = 0 ;
472 7 : if (g_echo) { ECHO; }
473 7 : sscanf( & yytext[1], "%o", &octal) ;
474 7 : if (octal > 0xFF)
475 : {
476 2 : yyerror("character literal: bad octal escape sequence") ;
477 2 : current_char = '\0' ;
478 : }
479 : else
480 : {
481 5 : current_char = octal ;
482 : }
483 7 : nb_char++ ;
484 7 : break ; }
485 :
486 : "\\x"[0-9A-Fa-f]{1,2} {
487 9 : unsigned int hexa = 0 ;
488 9 : if (g_echo) { ECHO; }
489 9 : sscanf( & yytext[2], "%x", &hexa) ;
490 9 : current_char = hexa ;
491 9 : nb_char++ ;
492 9 : break ; }
493 :
494 : "\\u" {
495 10 : yyerror("Attempt to use a unicode escape sequence in a char") ;
496 10 : break ; }
497 :
498 : "'" {
499 : int result ;
500 : IDLValue *v = NULL ;
501 67 : if (g_echo) { ECHO; }
502 67 : if (nb_char == 0)
503 : {
504 0 : yyerror("empty character litteral") ;
505 : }
506 67 : if (nb_char >= 2)
507 : {
508 14 : yyerror("multi character litteral") ;
509 : }
510 67 : v = new IDLCharValue(current_char) ;
511 : result = character_literal ;
512 67 : IDLConstExp *exp = new IDLValueExp(v) ;
513 67 : yylval.ConstExpPtr = exp ;
514 67 : BEGIN(INITIAL) ;
515 67 : return result ; }
516 :
517 : \007|\010|\011|\012|\013|\014|\015 {
518 2 : yyerror("Control character in a character literal") ;
519 2 : current_char = yytext[0] ;
520 2 : if (current_char == '\n')
521 : {
522 1 : IDLLineNumber++ ;
523 : }
524 2 : nb_char++ ;
525 2 : break ; }
526 :
527 : "\\". {
528 5 : yyerror("Unknown escape sequence") ;
529 5 : current_char = '\0' ;
530 5 : nb_char++ ;
531 5 : break ; }
532 61 : . { if (g_echo) { ECHO; } current_char = yytext[0] ; nb_char++ ; break ; }
533 : }
534 :
535 : <wcharacter>{
536 : "??=" {
537 0 : unput('#') ;
538 0 : break ; }
539 : "??(" {
540 0 : unput('[') ;
541 0 : break ; }
542 : "??)" {
543 0 : unput(']') ;
544 0 : break ; }
545 : "??<" {
546 0 : unput('{') ;
547 0 : break ; }
548 : "??>" {
549 0 : unput('}') ;
550 0 : break ; }
551 : "??/" {
552 0 : unput('\\') ;
553 0 : break ; }
554 : "\\??/" {
555 0 : unput('\\') ;
556 0 : unput('\\') ;
557 0 : break ; }
558 : "??'" {
559 0 : unput('^') ;
560 0 : break ; }
561 : "??!" {
562 0 : unput('|') ;
563 0 : break ; }
564 : "??-" {
565 0 : unput('~') ;
566 0 : break ; }
567 :
568 : "\\n" {
569 1 : if (g_echo) { ECHO; }
570 1 : current_wchar = L'\n' ;
571 1 : nb_char++ ;
572 1 : break ; }
573 : "\\t" {
574 1 : if (g_echo) { ECHO; }
575 1 : current_wchar = L'\t' ;
576 1 : nb_char++ ;
577 1 : break ; }
578 : "\\v" {
579 1 : if (g_echo) { ECHO; }
580 1 : current_wchar = L'\v' ;
581 1 : nb_char++ ;
582 1 : break ; }
583 : "\\b" {
584 1 : if (g_echo) { ECHO; }
585 1 : current_wchar = L'\b' ;
586 1 : nb_char++ ;
587 1 : break ; }
588 : "\\r" {
589 1 : if (g_echo) { ECHO; }
590 1 : current_wchar = L'\r' ;
591 1 : nb_char++ ;
592 1 : break ; }
593 : "\\f" {
594 2 : if (g_echo) { ECHO; }
595 2 : current_wchar = L'\f' ;
596 2 : nb_char++ ;
597 2 : break ; }
598 : "\\a" {
599 1 : if (g_echo) { ECHO; }
600 1 : current_wchar = L'\a' ;
601 1 : nb_char++ ;
602 1 : break ; }
603 : "\\\\" {
604 1 : if (g_echo) { ECHO; }
605 1 : current_wchar = L'\\' ;
606 1 : nb_char++ ;
607 1 : break ; }
608 : "\\'" {
609 1 : if (g_echo) { ECHO; }
610 1 : current_wchar = L'\'' ;
611 1 : nb_char++ ;
612 1 : break ; }
613 :
614 : "\\"[0-7]{1,3} {
615 7 : unsigned int octal = 0 ;
616 7 : if (g_echo) { ECHO; }
617 7 : sscanf( & yytext[1], "%o", &octal) ;
618 7 : current_wchar = octal ;
619 7 : nb_char++ ;
620 7 : break ; }
621 :
622 : "\\x"[0-9A-Fa-f]{1,2} {
623 9 : unsigned int hexa = 0 ;
624 9 : if (g_echo) { ECHO; }
625 9 : sscanf( & yytext[2], "%x", &hexa) ;
626 9 : current_wchar = hexa ;
627 9 : nb_char++ ;
628 9 : break ; }
629 :
630 : "\\u"[0-9A-Fa-f]{1,4} {
631 10 : unsigned int hexa = 0 ;
632 10 : if (g_echo) { ECHO; }
633 10 : sscanf( & yytext[2], "%x", &hexa) ;
634 10 : current_wchar = hexa ;
635 10 : nb_char++ ;
636 10 : break ; }
637 :
638 : "'" {
639 : int result ;
640 : IDLValue *v = NULL ;
641 55 : if (g_echo) { ECHO; }
642 55 : if (nb_char == 0)
643 : {
644 0 : yyerror("empty character litteral") ;
645 : }
646 55 : if (nb_char >= 2)
647 : {
648 5 : yyerror("multi character litteral") ;
649 : }
650 55 : v = new IDLWCharValue(current_wchar) ;
651 : result = wide_character_literal ;
652 55 : IDLConstExp *exp = new IDLValueExp(v) ;
653 55 : yylval.ConstExpPtr = exp ;
654 55 : BEGIN(INITIAL) ;
655 55 : return result ; }
656 :
657 : \007|\010|\011|\012|\013|\014|\015 {
658 2 : yyerror("Control character in a character literal") ;
659 2 : current_wchar = yytext[0] ;
660 2 : if (current_wchar == '\n')
661 : {
662 1 : IDLLineNumber++ ;
663 : }
664 2 : nb_char++ ;
665 2 : break ; }
666 :
667 : "\\". {
668 5 : yyerror("Unknown escape sequence") ;
669 5 : current_wchar = '\0' ;
670 5 : nb_char++ ;
671 5 : break ; }
672 19 : . { if (g_echo) { ECHO; } current_wchar = yytext[0] ; nb_char++ ; break ; }
673 : }
674 :
675 : <string>{
676 : "??=" {
677 1 : unput('#') ;
678 1 : break ; }
679 : "??(" {
680 1 : unput('[') ;
681 1 : break ; }
682 : "??)" {
683 1 : unput(']') ;
684 1 : break ; }
685 : "??<" {
686 1 : unput('{') ;
687 1 : break ; }
688 : "??>" {
689 1 : unput('}') ;
690 1 : break ; }
691 : "??/" {
692 5 : unput('\\') ;
693 5 : break ; }
694 : "\\??/" {
695 1 : unput('\\') ;
696 1 : unput('\\') ;
697 1 : break ; }
698 : "??'" {
699 1 : unput('^') ;
700 1 : break ; }
701 : "??!" {
702 1 : unput('|') ;
703 1 : break ; }
704 : "??-" {
705 1 : unput('~') ;
706 1 : break ; }
707 :
708 : "\\n" {
709 1 : if (g_echo) { ECHO; }
710 1 : current_string += '\n' ;
711 1 : break ; }
712 : "\\t" {
713 2 : if (g_echo) { ECHO; }
714 2 : current_string += '\t' ;
715 2 : break ; }
716 : "\\v" {
717 1 : if (g_echo) { ECHO; }
718 1 : current_string += '\v' ;
719 1 : break ; }
720 : "\\b" {
721 1 : if (g_echo) { ECHO; }
722 1 : current_string += '\b' ;
723 1 : break ; }
724 : "\\r" {
725 1 : if (g_echo) { ECHO; }
726 1 : current_string += '\r' ;
727 1 : break ; }
728 : "\\f" {
729 1 : if (g_echo) { ECHO; }
730 1 : current_string += '\f' ;
731 1 : break ; }
732 : "\\a" {
733 1 : if (g_echo) { ECHO; }
734 1 : current_string += '\a' ;
735 1 : break ; }
736 : "\\\\" {
737 2 : if (g_echo) { ECHO; }
738 2 : current_string += '\\' ;
739 2 : break ; }
740 : "\\\"" {
741 1 : if (g_echo) { ECHO; }
742 1 : current_string += '"' ;
743 1 : break ; }
744 :
745 : "\\"[0-7]{1,3} {
746 9 : unsigned int octal = 0 ;
747 9 : if (g_echo) { ECHO; }
748 9 : sscanf( & yytext[1], "%o", &octal) ;
749 9 : if (octal == 0)
750 : {
751 2 : yyerror("Character \\0 in a string literal") ;
752 : }
753 9 : if (octal > 0xFF)
754 : {
755 2 : yyerror("string literal: bad octal escape sequence") ;
756 : }
757 : else
758 : {
759 7 : current_string += (char) octal ;
760 : }
761 : break ; }
762 :
763 : "\\x"[0-9A-Fa-f]{1,2} {
764 5 : unsigned int hexa = 0 ;
765 5 : if (g_echo) { ECHO; }
766 5 : sscanf( & yytext[2], "%x", &hexa) ;
767 5 : if (hexa == 0)
768 : {
769 1 : yyerror("Character \\0 in a string literal") ;
770 : }
771 5 : current_string += (char) hexa ;
772 5 : break ; }
773 :
774 : "\\u" {
775 5 : yyerror("Attempt to use a unicode escape sequence in a string") ;
776 5 : break ; }
777 :
778 : \007|\010|\011|\012|\013|\014|\015 {
779 2 : yyerror("Control character in a string literal") ;
780 2 : current_char = yytext[0] ;
781 2 : if (current_char == '\n')
782 : {
783 1 : IDLLineNumber++ ;
784 : }
785 : break ; }
786 :
787 : "\"" {
788 24 : if (g_echo) { ECHO; }
789 24 : yylval.StringPtr = new String(current_string) ;
790 24 : BEGIN(INITIAL) ;
791 24 : return string_literal_unit ; }
792 :
793 : "\\". {
794 1 : yyerror("Unknown escape sequence") ;
795 1 : break ; }
796 :
797 280 : . { if (g_echo) { ECHO; } current_string += yytext[0] ; break ; }
798 :
799 : }
800 :
801 : <wstring>{
802 : "??=" {
803 1 : unput('#') ;
804 1 : break ; }
805 : "??(" {
806 1 : unput('[') ;
807 1 : break ; }
808 : "??)" {
809 1 : unput(']') ;
810 1 : break ; }
811 : "??<" {
812 1 : unput('{') ;
813 1 : break ; }
814 : "??>" {
815 1 : unput('}') ;
816 1 : break ; }
817 : "??/" {
818 5 : unput('\\') ;
819 5 : break ; }
820 : "\\??/" {
821 1 : unput('\\') ;
822 1 : unput('\\') ;
823 1 : break ; }
824 : "??'" {
825 1 : unput('^') ;
826 1 : break ; }
827 : "??!" {
828 1 : unput('|') ;
829 1 : break ; }
830 : "??-" {
831 1 : unput('~') ;
832 1 : break ; }
833 :
834 : "\\n" {
835 1 : if (g_echo) { ECHO; }
836 1 : current_wstring += L'\n' ;
837 1 : break ; }
838 : "\\t" {
839 2 : if (g_echo) { ECHO; }
840 2 : current_wstring += L'\t' ;
841 2 : break ; }
842 : "\\v" {
843 1 : if (g_echo) { ECHO; }
844 1 : current_wstring += L'\v' ;
845 1 : break ; }
846 : "\\b" {
847 1 : if (g_echo) { ECHO; }
848 1 : current_wstring += L'\b' ;
849 1 : break ; }
850 : "\\r" {
851 1 : if (g_echo) { ECHO; }
852 1 : current_wstring += L'\r' ;
853 1 : break ; }
854 : "\\f" {
855 1 : if (g_echo) { ECHO; }
856 1 : current_wstring += L'\f' ;
857 1 : break ; }
858 : "\\a" {
859 1 : if (g_echo) { ECHO; }
860 1 : current_wstring += L'\a' ;
861 1 : break ; }
862 : "\\\\" {
863 2 : if (g_echo) { ECHO; }
864 2 : current_wstring += L'\\' ;
865 2 : break ; }
866 : "\\\"" {
867 1 : if (g_echo) { ECHO; }
868 1 : current_wstring += L'"' ;
869 1 : break ; }
870 :
871 : "\\"[0-7]{1,3} {
872 2 : unsigned int octal = 0 ;
873 2 : if (g_echo) { ECHO; }
874 2 : sscanf( & yytext[1], "%o", &octal) ;
875 2 : if (octal == 0)
876 : {
877 1 : yyerror("Character \\0 in a wide string literal") ;
878 : }
879 2 : current_wstring += (wchar_t) octal ;
880 2 : break ; }
881 :
882 : "\\x"[0-9A-Fa-f]{1,2} {
883 2 : unsigned int hexa = 0 ;
884 2 : if (g_echo) { ECHO; }
885 2 : sscanf( & yytext[2], "%x", &hexa) ;
886 2 : if (hexa == 0)
887 : {
888 1 : yyerror("Character \\0 in a wide string literal") ;
889 : }
890 2 : current_wstring += (wchar_t) hexa ;
891 2 : break ; }
892 :
893 : "\\u"[0-9A-Fa-f]{1,4} {
894 5 : unsigned int hexa = 0 ;
895 5 : if (g_echo) { ECHO; }
896 5 : sscanf( & yytext[2], "%x", &hexa) ;
897 5 : if (hexa == 0)
898 : {
899 1 : yyerror("Character \\0 in a wide string literal") ;
900 : }
901 5 : current_wstring += (wchar_t) hexa ;
902 5 : break ; }
903 :
904 : \007|\010|\011|\012|\013|\014|\015 {
905 2 : yyerror("Control character in a wide string literal") ;
906 2 : current_char = yytext[0] ;
907 2 : if (current_char == '\n')
908 : {
909 1 : IDLLineNumber++ ;
910 : }
911 : break ; }
912 :
913 : "\"" {
914 10 : if (g_echo) { ECHO; }
915 10 : yylval.WStringPtr = new WString(current_wstring) ;
916 10 : BEGIN(INITIAL) ;
917 10 : return wide_string_literal_unit ; }
918 :
919 : "\\". {
920 1 : yyerror("Unknown escape sequence") ;
921 1 : break ; }
922 :
923 92 : . { if (g_echo) { ECHO; } current_wstring += (wchar_t) yytext[0] ; break ; }
924 :
925 : }
926 :
927 : <preprocessor>{
928 :
929 : {space} {
930 : break ; }
931 :
932 : "error"{space}+{quoted_string}{space}*{CR} {
933 3 : char *text = strdup(yytext) ;
934 : char *tmp = text ;
935 3 : tmp += 5 ; // Eat error
936 3 : while (isspace(*tmp)) tmp++ ;
937 3 : IDLCompileError(tmp) ;
938 3 : free (text) ;
939 3 : IDLLineNumber ++ ;
940 3 : BEGIN(INITIAL) ;
941 3 : break ; }
942 :
943 : "line"{space}+{digits}{space}*{CR} {
944 2 : char *tmp = yytext ;
945 : tmp += 4 ; // Eat line
946 : IDLLineNumber = atoi(tmp) ;
947 2 : IDLLineNumber ++ ; // trailing CR
948 2 : BEGIN(INITIAL) ;
949 2 : break ; }
950 :
951 : "line"{space}+{digits}{space}+{quoted_string}{space}*{CR} {
952 1 : char *buf = strdup(yytext) ;
953 : char *tmp = buf ;
954 1 : tmp += 4 ; // Eat line
955 : IDLLineNumber = atoi(tmp) ;
956 1 : IDLLineNumber ++ ; // trailing CR
957 1 : while (*tmp != '\"') tmp++ ;
958 1 : char *file_start_here = ++tmp ;
959 1 : while (*tmp != '\"') tmp++ ;
960 : char *file_stop_here = tmp ;
961 1 : *file_stop_here = '\0' ; // reason of strdup
962 1 : IDLFileName = file_start_here ;
963 1 : free (buf) ;
964 1 : BEGIN(INITIAL) ;
965 1 : break ; }
966 :
967 : "pragma"{space} {
968 657 : BEGIN(_pragma) ;
969 657 : break ; }
970 :
971 : "include" {
972 82 : BEGIN(_include) ;
973 82 : break ; }
974 :
975 : "define" {
976 96 : BEGIN(_define) ;
977 96 : break ; }
978 :
979 : "ifdef" {
980 9 : BEGIN(_ifdef) ;
981 9 : break ; }
982 :
983 : "ifndef" {
984 115 : BEGIN(_ifndef) ;
985 115 : break ; }
986 :
987 : "if" {
988 0 : BEGIN(_if) ;
989 0 : break ; }
990 :
991 : "else" {
992 2 : if (ifdefStackIndex == -1)
993 : {
994 0 : IDLFatalCompileError("Extra #else found.") ;
995 : }
996 : int nextAutomaton ;
997 2 : if (ifdefInfoStack[ifdefStackIndex] == before_activation)
998 : {
999 0 : ifdefInfoStack[ifdefStackIndex] = during_activation ;
1000 : nextAutomaton = INITIAL ;
1001 : }
1002 : else
1003 : {
1004 : nextAutomaton = silent ;
1005 : }
1006 2 : BEGIN(nextAutomaton) ;
1007 2 : break ; }
1008 :
1009 : "elif" {
1010 0 : BEGIN(_elif) ;
1011 0 : break ; }
1012 :
1013 : "endif" {
1014 104 : if (ifdefStackIndex >= 0)
1015 : {
1016 104 : ifdefStackIndex -- ;
1017 104 : BEGIN(INITIAL) ;
1018 : }
1019 : else
1020 : {
1021 0 : IDLFatalCompileError("Extra #endif found.") ;
1022 : }
1023 : break ; }
1024 :
1025 : {CR} {
1026 2 : IDLLineNumber ++ ;
1027 2 : BEGIN(INITIAL) ;
1028 2 : break ; }
1029 :
1030 0 : . { yyerror("unknown pre-processor command") ; break ; }
1031 : }
1032 :
1033 : <_include>{
1034 :
1035 : {space} { break ; }
1036 :
1037 : {user_file}|{system_file} {
1038 82 : includeStackIndex ++ ;
1039 82 : if (includeStackIndex >= IDL_MAX_INCLUDE_DEPTH)
1040 : {
1041 0 : IDLFatalCompileError("Includes nested too deply") ;
1042 : }
1043 82 : char *filename = strdup(yytext+1) ; // Eat first quote
1044 82 : filename[strlen(filename) -1] = '\0' ; // Eat last quote
1045 82 : String fullname ;
1046 82 : yyin = FindFile(filename, fullname) ;
1047 82 : if ( ! yyin)
1048 : {
1049 0 : String errmsg = "Can not find include file <" ;
1050 0 : errmsg += filename ;
1051 0 : errmsg += ">" ;
1052 0 : IDLFatalCompileError(errmsg) ;
1053 : }
1054 82 : includeStack[includeStackIndex]._buffer = YY_CURRENT_BUFFER ;
1055 82 : includeStack[includeStackIndex]._fileName = IDLFileName ;
1056 82 : includeStack[includeStackIndex]._fileFullName = fullname ;
1057 82 : includeStack[includeStackIndex]._lineNumber = IDLLineNumber ;
1058 82 : IDLFileName = filename ;
1059 82 : IDLLineNumber = 1 ;
1060 82 : g_symTabPtr->SetPrefix("") ;
1061 82 : yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE)) ;
1062 82 : free (filename) ;
1063 82 : BEGIN(INITIAL) ;
1064 82 : break ; }
1065 :
1066 0 : . { yyerror("FIXME #include") ; break ; }
1067 : }
1068 :
1069 : <_define>{
1070 :
1071 : {space} {
1072 : break ; }
1073 :
1074 : {identifier} {
1075 96 : NON_DEV("define value & macro") ;
1076 96 : g_defineTable->AddDefine(yytext, "1") ;
1077 96 : BEGIN(INITIAL) ;
1078 96 : break ; }
1079 :
1080 0 : . { yyerror("FIXME #define") ; break ; }
1081 : }
1082 :
1083 : <_if>{
1084 :
1085 : {space} {
1086 : break ; }
1087 :
1088 0 : . { yyerror("FIXME #if") ; break ; }
1089 : }
1090 :
1091 : <_ifdef>{
1092 :
1093 : {space} {
1094 : break ; }
1095 :
1096 : {identifier} {
1097 9 : ifdefStackIndex ++ ;
1098 9 : if (ifdefStackIndex >= IDL_MAX_IFDEF_DEPTH)
1099 : {
1100 0 : IDLFatalCompileError("#if/#ifdef/#ifndef neested too deeply.") ;
1101 : }
1102 : int nextAutomaton ;
1103 9 : if (g_defineTable->IsDefined(yytext))
1104 : {
1105 1 : ifdefInfoStack[ifdefStackIndex] = during_activation ;
1106 : nextAutomaton = INITIAL ;
1107 : }
1108 : else
1109 : {
1110 8 : ifdefInfoStack[ifdefStackIndex] = before_activation ;
1111 : nextAutomaton = silent ;
1112 8 : silentNestedIfdef = 0 ;
1113 : }
1114 9 : BEGIN(nextAutomaton) ;
1115 9 : break ; }
1116 :
1117 0 : . { yyerror("FIXME #ifdef") ; break ; }
1118 : }
1119 :
1120 : <_ifndef>{
1121 :
1122 : {space} {
1123 : break ; }
1124 :
1125 : {identifier} {
1126 115 : ifdefStackIndex ++ ;
1127 115 : if (ifdefStackIndex >= IDL_MAX_IFDEF_DEPTH)
1128 : {
1129 0 : IDLFatalCompileError("#if/#ifdef/#ifndef neested too deeply.") ;
1130 : }
1131 : int nextAutomaton ;
1132 115 : if ( ! g_defineTable->IsDefined(yytext))
1133 : {
1134 96 : ifdefInfoStack[ifdefStackIndex] = during_activation ;
1135 : nextAutomaton = INITIAL ;
1136 : }
1137 : else
1138 : {
1139 19 : ifdefInfoStack[ifdefStackIndex] = before_activation ;
1140 : nextAutomaton = silent ;
1141 19 : silentNestedIfdef = 0 ;
1142 : }
1143 115 : BEGIN(nextAutomaton) ;
1144 115 : break ; }
1145 :
1146 0 : . { yyerror("FIXME #ifndef") ; break ; }
1147 : }
1148 :
1149 : <_elif>{
1150 :
1151 : {space} {
1152 : break ; }
1153 :
1154 : {identifier} {
1155 0 : yyerror("FIXME #elif") ;
1156 0 : break ; }
1157 :
1158 0 : . { yyerror("FIXME #elif") ; break ; }
1159 : }
1160 :
1161 : <_pragma>{
1162 : "ID"{space}{pragma_name}{space}{pragma_string}{space}?{CR} {
1163 1 : char *buf = strdup(yytext) ; // Don't want to hack yytext, use a copy
1164 : char *tmp = buf ;
1165 1 : tmp += 2 ; // 'ID' ;
1166 1 : while (isspace(*tmp)) tmp++ ;
1167 : char *name_start_here = tmp ;
1168 3 : while (! isspace(*tmp)) tmp++ ;
1169 : char *name_stop_here = tmp ;
1170 2 : while ((*tmp) != '\"') tmp++ ;
1171 1 : tmp++ ; // '"' character
1172 : char * id_start_here = tmp ;
1173 1 : while ((*tmp) != '\"') tmp++ ;
1174 : char * id_stop_here = tmp ;
1175 1 : *name_stop_here = '\0' ;
1176 1 : *id_stop_here = '\0' ;
1177 1 : String name = name_start_here ;
1178 1 : String id = id_start_here ;
1179 1 : free (buf) ;
1180 1 : NON_DEV("#pragma ID") ;
1181 1 : errLog << "#pragma ID : NAME=<" << name << ">, ID=<" << id << ">" ;
1182 : errLog << std::endl ;
1183 1 : IDLLineNumber ++ ;
1184 1 : BEGIN(INITIAL) ;
1185 1 : break ; }
1186 :
1187 : "prefix"{space}{pragma_string}{space}?{CR} {
1188 88 : char *buf = strdup(yytext) ;
1189 : char *tmp = buf ;
1190 88 : tmp += 6 ; // "prefix" ;
1191 88 : while ((*tmp) != '\"') tmp++ ;
1192 88 : tmp++ ;
1193 : char *prefix_start_here = tmp ;
1194 88 : while ((*tmp) != '\"') tmp++ ;
1195 : char *prefix_stop_here = tmp ;
1196 88 : *prefix_stop_here = '\0' ;
1197 88 : String prefix = prefix_start_here ;
1198 88 : free(buf) ;
1199 88 : g_symTabPtr->SetPrefix(prefix) ;
1200 88 : IDLLineNumber ++ ;
1201 88 : BEGIN(INITIAL) ;
1202 88 : break ; }
1203 :
1204 : "version"{space}{pragma_name}{space}{pragma_version}{space}?{CR} {
1205 568 : char *buf = strdup(yytext) ;
1206 : char *tmp = buf ;
1207 568 : tmp += 7 ; // "version"
1208 568 : while (isspace(*tmp)) tmp++ ;
1209 : char *name_start_here = tmp ;
1210 6130 : while (! isspace(*tmp)) tmp++ ;
1211 : char *name_stop_here = tmp ;
1212 568 : while (isspace(*tmp)) tmp++ ;
1213 : char *version_start_here = tmp ;
1214 : int major, minor ;
1215 568 : *name_stop_here = '\0' ;
1216 568 : String name = name_start_here ;
1217 568 : sscanf(version_start_here, "%d.%d", &major, &minor) ;
1218 568 : free (buf) ;
1219 568 : NON_DEV("version") ;
1220 568 : errLog << "#pragma version : NAME=<" << name ;
1221 568 : errLog << ">, MAJOR=<" << major ;
1222 1136 : errLog << ">, MINOR=<" << minor << ">" ;
1223 : errLog << std::endl ;
1224 568 : IDLLineNumber ++ ;
1225 568 : BEGIN(INITIAL) ;
1226 568 : break ; }
1227 :
1228 0 : . { yyerror("unknown #pragma, FIXME(must ignore)") ; BEGIN(INITIAL) ; break ; }
1229 : }
1230 :
1231 : <silent>{
1232 : ("#"|"??="){space}*("ifdef"|"ifndef"|"if") {
1233 0 : silentNestedIfdef ++ ;
1234 0 : break ; }
1235 :
1236 : ("#"|"??="){space}*"else" {
1237 9 : if (silentNestedIfdef == 0)
1238 : {
1239 9 : if (ifdefInfoStack[ifdefStackIndex] == before_activation)
1240 : {
1241 9 : ifdefInfoStack[ifdefStackIndex] = during_activation ;
1242 9 : BEGIN(INITIAL) ;
1243 : }
1244 : else
1245 : {
1246 : ASSERT(ifdefInfoStack[ifdefStackIndex] == after_activation) ;
1247 : }
1248 : }
1249 : break ; }
1250 :
1251 : ("#"|"??="){space}*"elif" {
1252 0 : NON_DEV("silent- elif") ;
1253 0 : if (silentNestedIfdef == 0)
1254 : {
1255 0 : BEGIN(_elif) ;
1256 : }
1257 : break ; }
1258 :
1259 : ("#"|"??="){space}*"endif" {
1260 20 : if (silentNestedIfdef == 0)
1261 : {
1262 : ASSERT (ifdefStackIndex >= 0) ;
1263 20 : ifdefStackIndex -- ;
1264 20 : BEGIN(INITIAL) ;
1265 : }
1266 20 : silentNestedIfdef -- ;
1267 20 : break ; }
1268 :
1269 6636 : {CR} { IDLLineNumber ++ ; break ; }
1270 : . { break ; }
1271 : }
1272 :
|
