LTP GCOV extension - code coverage report
Current view: directory - src/cpp/dev/idlc - idl_flex.ll
Test: YAORB-0.2.info
Date: 2006-02-27 Instrumented lines: 623
Code covered: 90.0 % Executed lines: 561

       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                 : 

Generated by: LTP GCOV extension version 1.4