Ignore:
Timestamp:
Dec 3, 2014, 3:08:38 PM (10 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc
Children:
d9a0e76
Parents:
42dcae7
Message:

underscore changes, ptrdiff_t changes, formating, _Bool prelude

File:
1 edited

Legend:

Unmodified
Added
Removed

  • translator/Parser/lex.l

    r42dcae7 r3848e0e  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Tue Nov 11 08:10:05 2014
    13  * Update Count     : 215
     12 * Last Modified On : Wed Dec  3 13:37:52 2014
     13 * Update Count     : 317
    1414 */
    1515
    … …  
    3131
    3232char *yyfilename;
     33std::string *strtext;                                   // accumulate parts of character and string constant value
    3334
    3435#define WHITE_RETURN(x)                                 // do nothing
    … …  
    3839                                yylval.tok.loc.line = yylineno; \
    3940                                return(x)
     41#define RETURN_STR(x)           yylval.tok.str = strtext; \
     42                                yylval.tok.loc.file = yyfilename; \
     43                                yylval.tok.loc.line = yylineno; \
     44                                return(x)
    4045
    4146#define KEYWORD_RETURN(x)       RETURN_VAL(x)           // keyword
    … …  
    4954#define NUMERIC_RETURN(x)       rm_underscore(); RETURN_VAL(x) // numeric constant
    5055
    51 void rm_underscore() {                                  // remove underscores in constant or escape sequence
     56void rm_underscore() {
     57    // remove underscores in numeric constant
    5258    int j = 0;
    53     for ( int i = 0; i < yyleng; i += 1 ) {
     59    for ( int i = 0; yytext[i] != '\0'; i += 1 ) {
    5460        if ( yytext[i] != '_' ) {
    5561            yytext[j] = yytext[i];
    … …  
    6773decimal [0-9]
    6874hex [0-9a-fA-F]
    69 universal_char "\\"((u{hex_quad})|(U{hex_quad}{2}))
     75universal_char "\\"((u"_"?{hex_quad})|(U"_"?{hex_quad}{2}))
    7076
    7177        // identifier, GCC: $ in identifier
    … …  
    7985
    8086        // numeric constants, CFA: '_' in constant
    81 hex_quad {hex}{4}
     87hex_quad {hex}("_"?{hex}){3}
    8288integer_suffix "_"?(([uU][lL]?)|([uU]("ll"|"LL")?)|([lL][uU]?)|("ll"|"LL")[uU]?)
    8389
    … …  
    106112simple_escape "\\"[abefnrtv'"?\\]
    107113        // ' stop highlighting
    108 octal_escape "\\"{octal}{1,3}
    109 hex_escape "\\""x"{hex}+
     114octal_escape "\\"{octal}("_"?{octal}){0,2}
     115hex_escape "\\""x""_"?{hex_digits}
    110116escape_seq {simple_escape}|{octal_escape}|{hex_escape}|{universal_char}
    111117
    … …  
    129135
    130136%x COMMENT
    131 %x QUOTED
     137%x BKQUOTE
     138%x QUOTE
     139%x STRING
    132140
    133141%%
    … …  
    141149        lineno = strtol( yytext + 1, &end_num, 0 );
    142150        begin_string = strchr( end_num, '"' );
    143         if( begin_string ) {
    144           end_string = strchr( begin_string + 1, '"' );
    145           if( end_string ) {
    146             length = end_string - begin_string - 1;
    147             filename = new char[ length + 1 ];
    148             memcpy( filename, begin_string + 1, length );
    149             filename[ length ] = '\0';
    150             //std::cout << "file " << filename << " line " << lineno << std::endl;
    151             yylineno = lineno;
    152             yyfilename = filename;
    153           }
     151        if ( begin_string ) {
     152            end_string = strchr( begin_string + 1, '"' );
     153            if ( end_string ) {
     154                length = end_string - begin_string - 1;
     155                filename = new char[ length + 1 ];
     156                memcpy( filename, begin_string + 1, length );
     157                filename[ length ] = '\0';
     158                //std::cout << "file " << filename << " line " << lineno << std::endl;
     159                yylineno = lineno;
     160                yyfilename = filename;
     161            }
    154162        }
    155163}
    … …  
    159167
    160168        /* ignore C style comments */
    161 "/*"                    {BEGIN COMMENT;}
     169"/*"                    { BEGIN COMMENT; }
    162170<COMMENT>.|\n           ;
    163 <COMMENT>"*/"           {BEGIN 0;}
     171<COMMENT>"*/"           { BEGIN 0; }
    164172
    165173        /* ignore C++ style comments */
    … …  
    167175
    168176        /* ignore whitespace */
    169 {h_white}+              {WHITE_RETURN(' ');}
    170 ({v_tab}|{c_return}|{form_feed})+ {WHITE_RETURN(' ');}
    171 ({h_white}|{v_tab}|{c_return}|{form_feed})*"\n" {NEWLINE_RETURN();}
     177{h_white}+              { WHITE_RETURN(' '); }
     178({v_tab}|{c_return}|{form_feed})+ { WHITE_RETURN(' '); }
     179({h_white}|{v_tab}|{c_return}|{form_feed})*"\n" { NEWLINE_RETURN(); }
    172180
    173181        /* keywords */
    174 __alignof               {KEYWORD_RETURN(ALIGNOF);}      /* GCC */
    175 __alignof__             {KEYWORD_RETURN(ALIGNOF);}      /* GCC */
    176 asm                     {KEYWORD_RETURN(ASM);}
    177 __asm                   {KEYWORD_RETURN(ASM);}          /* GCC */
    178 __asm__                 {KEYWORD_RETURN(ASM);}          /* GCC */
    179 __attribute             {KEYWORD_RETURN(ATTRIBUTE);}    /* GCC */
    180 __attribute__           {KEYWORD_RETURN(ATTRIBUTE);}    /* GCC */
    181 auto                    {KEYWORD_RETURN(AUTO);}
    182 _Bool                   {KEYWORD_RETURN(BOOL);}         /* ANSI99 */
    183 break                   {KEYWORD_RETURN(BREAK);}
    184 case                    {KEYWORD_RETURN(CASE);}
    185 catch                   {KEYWORD_RETURN(CATCH);}        /* CFA */
    186 char                    {KEYWORD_RETURN(CHAR);}
    187 choose                  {KEYWORD_RETURN(CHOOSE);}       /* CFA */
    188 _Complex                {KEYWORD_RETURN(COMPLEX);}      /* ANSI99 */
    189 __complex               {KEYWORD_RETURN(COMPLEX);}      /* GCC */
    190 __complex__             {KEYWORD_RETURN(COMPLEX);}      /* GCC */
    191 const                   {KEYWORD_RETURN(CONST);}
    192 __const                 {KEYWORD_RETURN(CONST);}        /* GCC */
    193 __const__               {KEYWORD_RETURN(CONST);}        /* GCC */
    194 context                 {KEYWORD_RETURN(CONTEXT);}      /* CFA */
    195 continue                {KEYWORD_RETURN(CONTINUE);}
    196 default                 {KEYWORD_RETURN(DEFAULT);}
    197 do                      {KEYWORD_RETURN(DO);}
    198 double                  {KEYWORD_RETURN(DOUBLE);}
    199 dtype                   {KEYWORD_RETURN(DTYPE);}        /* CFA */
    200 else                    {KEYWORD_RETURN(ELSE);}
    201 enum                    {KEYWORD_RETURN(ENUM);}
    202 __extension__           {KEYWORD_RETURN(EXTENSION);}    /* GCC */
    203 extern                  {KEYWORD_RETURN(EXTERN);}
    204 fallthru                {KEYWORD_RETURN(FALLTHRU);}     /* CFA */
    205 finally                 {KEYWORD_RETURN(FINALLY);}      /* CFA */
    206 float                   {KEYWORD_RETURN(FLOAT);}
    207 for                     {KEYWORD_RETURN(FOR);}
    208 forall                  {KEYWORD_RETURN(FORALL);}       /* CFA */
    209 fortran                 {KEYWORD_RETURN(FORTRAN);}
    210 ftype                   {KEYWORD_RETURN(FTYPE);}        /* CFA */
    211 goto                    {KEYWORD_RETURN(GOTO);}
    212 if                      {KEYWORD_RETURN(IF);}
    213 _Imaginary              {KEYWORD_RETURN(IMAGINARY);}    /* ANSI99 */
    214 __imag                  {KEYWORD_RETURN(IMAGINARY);}    /* GCC */
    215 __imag__                {KEYWORD_RETURN(IMAGINARY);}    /* GCC */
    216 inline                  {KEYWORD_RETURN(INLINE);}       /* ANSI99 */
    217 __inline                {KEYWORD_RETURN(INLINE);}       /* GCC */
    218 __inline__              {KEYWORD_RETURN(INLINE);}       /* GCC */
    219 int                     {KEYWORD_RETURN(INT);}
    220 __label__               {KEYWORD_RETURN(LABEL);}        /* GCC */
    221 long                    {KEYWORD_RETURN(LONG);}
    222 lvalue                  {KEYWORD_RETURN(LVALUE);}       /* CFA */
    223 register                {KEYWORD_RETURN(REGISTER);}
    224 restrict                {KEYWORD_RETURN(RESTRICT);}     /* ANSI99 */
    225 __restrict              {KEYWORD_RETURN(RESTRICT);}     /* GCC */
    226 __restrict__            {KEYWORD_RETURN(RESTRICT);}     /* GCC */
    227 return                  {KEYWORD_RETURN(RETURN);}
    228 short                   {KEYWORD_RETURN(SHORT);}
    229 signed                  {KEYWORD_RETURN(SIGNED);}
    230 __signed                {KEYWORD_RETURN(SIGNED);}       /* GCC */
    231 __signed__              {KEYWORD_RETURN(SIGNED);}       /* GCC */
    232 sizeof                  {KEYWORD_RETURN(SIZEOF);}
    233 static                  {KEYWORD_RETURN(STATIC);}
    234 struct                  {KEYWORD_RETURN(STRUCT);}
    235 switch                  {KEYWORD_RETURN(SWITCH);}
    236 throw                   {KEYWORD_RETURN(THROW);}        /* CFA */
    237 try                     {KEYWORD_RETURN(TRY);}          /* CFA */
    238 type                    {KEYWORD_RETURN(TYPE);}         /* CFA */
    239 typedef                 {KEYWORD_RETURN(TYPEDEF);}
    240 typeof                  {KEYWORD_RETURN(TYPEOF);}       /* GCC */
    241 __typeof                {KEYWORD_RETURN(TYPEOF);}       /* GCC */
    242 __typeof__              {KEYWORD_RETURN(TYPEOF);}       /* GCC */
    243 union                   {KEYWORD_RETURN(UNION);}
    244 unsigned                {KEYWORD_RETURN(UNSIGNED);}
    245 void                    {KEYWORD_RETURN(VOID);}
    246 volatile                {KEYWORD_RETURN(VOLATILE);}
    247 __volatile              {KEYWORD_RETURN(VOLATILE);}     /* GCC */
    248 __volatile__            {KEYWORD_RETURN(VOLATILE);}     /* GCC */
    249 while                   {KEYWORD_RETURN(WHILE);}
     182__alignof               { KEYWORD_RETURN(ALIGNOF); }    // GCC
     183__alignof__             { KEYWORD_RETURN(ALIGNOF); }    // GCC
     184asm                     { KEYWORD_RETURN(ASM); }
     185__asm                   { KEYWORD_RETURN(ASM); }        // GCC
     186__asm__                 { KEYWORD_RETURN(ASM); }        // GCC
     187__attribute             { KEYWORD_RETURN(ATTRIBUTE); }  // GCC
     188__attribute__           { KEYWORD_RETURN(ATTRIBUTE); }  // GCC
     189auto                    { KEYWORD_RETURN(AUTO); }
     190_Bool                   { KEYWORD_RETURN(BOOL); }       // C99
     191break                   { KEYWORD_RETURN(BREAK); }
     192case                    { KEYWORD_RETURN(CASE); }
     193catch                   { KEYWORD_RETURN(CATCH); }      // CFA
     194char                    { KEYWORD_RETURN(CHAR); }
     195choose                  { KEYWORD_RETURN(CHOOSE); }     // CFA
     196_Complex                { KEYWORD_RETURN(COMPLEX); }    // C99
     197__complex               { KEYWORD_RETURN(COMPLEX); }    // GCC
     198__complex__             { KEYWORD_RETURN(COMPLEX); }    // GCC
     199const                   { KEYWORD_RETURN(CONST); }
     200__const                 { KEYWORD_RETURN(CONST); }      // GCC
     201__const__               { KEYWORD_RETURN(CONST); }      // GCC
     202context                 { KEYWORD_RETURN(CONTEXT); }    // CFA
     203continue                { KEYWORD_RETURN(CONTINUE); }
     204default                 { KEYWORD_RETURN(DEFAULT); }
     205do                      { KEYWORD_RETURN(DO); }
     206double                  { KEYWORD_RETURN(DOUBLE); }
     207dtype                   { KEYWORD_RETURN(DTYPE); }      // CFA
     208else                    { KEYWORD_RETURN(ELSE); }
     209enum                    { KEYWORD_RETURN(ENUM); }
     210__extension__           { KEYWORD_RETURN(EXTENSION); }  // GCC
     211extern                  { KEYWORD_RETURN(EXTERN); }
     212fallthru                { KEYWORD_RETURN(FALLTHRU); }   // CFA
     213finally                 { KEYWORD_RETURN(FINALLY); }    // CFA
     214float                   { KEYWORD_RETURN(FLOAT); }
     215for                     { KEYWORD_RETURN(FOR); }
     216forall                  { KEYWORD_RETURN(FORALL); }     // CFA
     217fortran                 { KEYWORD_RETURN(FORTRAN); }
     218ftype                   { KEYWORD_RETURN(FTYPE); }      // CFA
     219goto                    { KEYWORD_RETURN(GOTO); }
     220if                      { KEYWORD_RETURN(IF); }
     221_Imaginary              { KEYWORD_RETURN(IMAGINARY); }  // C99
     222__imag                  { KEYWORD_RETURN(IMAGINARY); }  // GCC
     223__imag__                { KEYWORD_RETURN(IMAGINARY); }  // GCC
     224inline                  { KEYWORD_RETURN(INLINE); }     // C99
     225__inline                { KEYWORD_RETURN(INLINE); }     // GCC
     226__inline__              { KEYWORD_RETURN(INLINE); }     // GCC
     227int                     { KEYWORD_RETURN(INT); }
     228__label__               { KEYWORD_RETURN(LABEL); }      // GCC
     229long                    { KEYWORD_RETURN(LONG); }
     230lvalue                  { KEYWORD_RETURN(LVALUE); }     // CFA
     231register                { KEYWORD_RETURN(REGISTER); }
     232restrict                { KEYWORD_RETURN(RESTRICT); }   // C99
     233__restrict              { KEYWORD_RETURN(RESTRICT); }   // GCC
     234__restrict__            { KEYWORD_RETURN(RESTRICT); }   // GCC
     235return                  { KEYWORD_RETURN(RETURN); }
     236short                   { KEYWORD_RETURN(SHORT); }
     237signed                  { KEYWORD_RETURN(SIGNED); }
     238__signed                { KEYWORD_RETURN(SIGNED); }     // GCC
     239__signed__              { KEYWORD_RETURN(SIGNED); }     // GCC
     240sizeof                  { KEYWORD_RETURN(SIZEOF); }
     241static                  { KEYWORD_RETURN(STATIC); }
     242struct                  { KEYWORD_RETURN(STRUCT); }
     243switch                  { KEYWORD_RETURN(SWITCH); }
     244throw                   { KEYWORD_RETURN(THROW); }      // CFA
     245try                     { KEYWORD_RETURN(TRY); }        // CFA
     246type                    { KEYWORD_RETURN(TYPE); }       // CFA
     247typedef                 { KEYWORD_RETURN(TYPEDEF); }
     248typeof                  { KEYWORD_RETURN(TYPEOF); }     // GCC
     249__typeof                { KEYWORD_RETURN(TYPEOF); }     // GCC
     250__typeof__              { KEYWORD_RETURN(TYPEOF); }     // GCC
     251union                   { KEYWORD_RETURN(UNION); }
     252unsigned                { KEYWORD_RETURN(UNSIGNED); }
     253void                    { KEYWORD_RETURN(VOID); }
     254volatile                { KEYWORD_RETURN(VOLATILE); }
     255__volatile              { KEYWORD_RETURN(VOLATILE); }   // GCC
     256__volatile__            { KEYWORD_RETURN(VOLATILE); }   // GCC
     257while                   { KEYWORD_RETURN(WHILE); }
    250258
    251259        /* identifier */
    252 {identifier}            {IDENTIFIER_RETURN();}
    253 {attr_identifier}       {ATTRIBUTE_RETURN();}
    254 "`"                     {BEGIN QUOTED;}
    255 <QUOTED>{identifier}    {IDENTIFIER_RETURN();}
    256 <QUOTED>"`"             {BEGIN 0;}
     260{identifier}            { IDENTIFIER_RETURN(); }
     261{attr_identifier}       { ATTRIBUTE_RETURN(); }
     262"`"                     { BEGIN BKQUOTE; }
     263<BKQUOTE>{identifier}   { IDENTIFIER_RETURN(); }
     264<BKQUOTE>"`"            { BEGIN 0; }
    257265
    258266        /* numeric constants */
    259 "0"                     {NUMERIC_RETURN(ZERO);}         /* CFA */
    260 "1"                     {NUMERIC_RETURN(ONE);}          /* CFA */
    261 {decimal_constant}      {NUMERIC_RETURN(INTEGERconstant);}
    262 {octal_constant}        {NUMERIC_RETURN(INTEGERconstant);}
    263 {hex_constant}          {NUMERIC_RETURN(INTEGERconstant);}
    264 {floating_constant}     {NUMERIC_RETURN(FLOATINGconstant);}
    265 {hex_floating_constant} {NUMERIC_RETURN(FLOATINGconstant);}
     267"0"                     { NUMERIC_RETURN(ZERO); }       // CFA
     268"1"                     { NUMERIC_RETURN(ONE); }        // CFA
     269{decimal_constant}      { NUMERIC_RETURN(INTEGERconstant); }
     270{octal_constant}        { NUMERIC_RETURN(INTEGERconstant); }
     271{hex_constant}          { NUMERIC_RETURN(INTEGERconstant); }
     272{floating_constant}     { NUMERIC_RETURN(FLOATINGconstant); }
     273{hex_floating_constant} { NUMERIC_RETURN(FLOATINGconstant); }
    266274
    267275        /* character constant, allows empty value */
    268 "L"?[']([^'\\\n]|{escape_seq})*['] {RETURN_VAL(CHARACTERconstant);}
     276"L"?"_"?[']             { BEGIN QUOTE; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
     277<QUOTE>[^'\\\n]*        { *strtext += std::string( yytext ); }
     278<QUOTE>['\n]            { BEGIN 0; *strtext += std::string( yytext); RETURN_STR(CHARACTERconstant); }
    269279        /* ' stop highlighting */
    270280
    271281        /* string constant */
    272 "L"?["]([^"\\\n]|{escape_seq})*["] {RETURN_VAL(STRINGliteral);}
     282"L"?"_"?["]             { BEGIN STRING; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
     283<STRING>[^"\\\n]*       { *strtext += std::string( yytext ); }
     284<STRING>["\n]           { BEGIN 0; *strtext += std::string( yytext); RETURN_STR(STRINGliteral); }
    273285        /* " stop highlighting */
    274286
     287<QUOTE,STRING>{escape_seq} { rm_underscore(); *strtext += std::string( yytext ); }
     288<QUOTE,STRING>[\\]      { *strtext += std::string( yytext ); } // unknown escape character
     289
    275290        /* punctuation */
    276 "["                     {ASCIIOP_RETURN();}
    277 "]"                     {ASCIIOP_RETURN();}
    278 "("                     {ASCIIOP_RETURN();}
    279 ")"                     {ASCIIOP_RETURN();}
    280 "{"                     {ASCIIOP_RETURN();}
    281 "}"                     {ASCIIOP_RETURN();}
    282 ","                     {ASCIIOP_RETURN();}             /* also operator */
    283 ":"                     {ASCIIOP_RETURN();}
    284 ";"                     {ASCIIOP_RETURN();}
    285 "."                     {ASCIIOP_RETURN();}             /* also operator */
    286 "..."                   {NAMEDOP_RETURN(ELLIPSIS);}
    287 
    288         /* alternative ANSI99 brackets, "<:" & "<:<:" handled by preprocessor */
    289 "<:"                    {RETURN_VAL('[');}
    290 ":>"                    {RETURN_VAL(']');}
    291 "<%"                    {RETURN_VAL('{');}
    292 "%>"                    {RETURN_VAL('}');}
     291"["                     { ASCIIOP_RETURN(); }
     292"]"                     { ASCIIOP_RETURN(); }
     293"("                     { ASCIIOP_RETURN(); }
     294")"                     { ASCIIOP_RETURN(); }
     295"{"                     { ASCIIOP_RETURN(); }
     296"}"                     { ASCIIOP_RETURN(); }
     297","                     { ASCIIOP_RETURN(); }           // also operator
     298":"                     { ASCIIOP_RETURN(); }
     299";"                     { ASCIIOP_RETURN(); }
     300"."                     { ASCIIOP_RETURN(); }           // also operator
     301"..."                   { NAMEDOP_RETURN(ELLIPSIS); }
     302
     303        /* alternative C99 brackets, "<:" & "<:<:" handled by preprocessor */
     304"<:"                    { RETURN_VAL('['); }
     305":>"                    { RETURN_VAL(']'); }
     306"<%"                    { RETURN_VAL('{'); }
     307"%>"                    { RETURN_VAL('}'); }
    293308
    294309        /* operators */
    295 "!"                     {ASCIIOP_RETURN();}
    296 "+"                     {ASCIIOP_RETURN();}
    297 "-"                     {ASCIIOP_RETURN();}
    298 "*"                     {ASCIIOP_RETURN();}
    299 "/"                     {ASCIIOP_RETURN();}
    300 "%"                     {ASCIIOP_RETURN();}
    301 "^"                     {ASCIIOP_RETURN();}
    302 "~"                     {ASCIIOP_RETURN();}
    303 "&"                     {ASCIIOP_RETURN();}
    304 "|"                     {ASCIIOP_RETURN();}
    305 "<"                     {ASCIIOP_RETURN();}
    306 ">"                     {ASCIIOP_RETURN();}
    307 "="                     {ASCIIOP_RETURN();}
    308 "?"                     {ASCIIOP_RETURN();}
    309 
    310 "++"                    {NAMEDOP_RETURN(ICR);}
    311 "--"                    {NAMEDOP_RETURN(DECR);}
    312 "=="                    {NAMEDOP_RETURN(EQ);}
    313 "!="                    {NAMEDOP_RETURN(NE);}
    314 "<<"                    {NAMEDOP_RETURN(LS);}
    315 ">>"                    {NAMEDOP_RETURN(RS);}
    316 "<="                    {NAMEDOP_RETURN(LE);}
    317 ">="                    {NAMEDOP_RETURN(GE);}
    318 "&&"                    {NAMEDOP_RETURN(ANDAND);}
    319 "||"                    {NAMEDOP_RETURN(OROR);}
    320 "->"                    {NAMEDOP_RETURN(ARROW);}
    321 "+="                    {NAMEDOP_RETURN(PLUSassign);}
    322 "-="                    {NAMEDOP_RETURN(MINUSassign);}
    323 "*="                    {NAMEDOP_RETURN(MULTassign);}
    324 "/="                    {NAMEDOP_RETURN(DIVassign);}
    325 "%="                    {NAMEDOP_RETURN(MODassign);}
    326 "&="                    {NAMEDOP_RETURN(ANDassign);}
    327 "|="                    {NAMEDOP_RETURN(ORassign);}
    328 "^="                    {NAMEDOP_RETURN(ERassign);}
    329 "<<="                   {NAMEDOP_RETURN(LSassign);}
    330 ">>="                   {NAMEDOP_RETURN(RSassign);}
     310"!"                     { ASCIIOP_RETURN(); }
     311"+"                     { ASCIIOP_RETURN(); }
     312"-"                     { ASCIIOP_RETURN(); }
     313"*"                     { ASCIIOP_RETURN(); }
     314"/"                     { ASCIIOP_RETURN(); }
     315"%"                     { ASCIIOP_RETURN(); }
     316"^"                     { ASCIIOP_RETURN(); }
     317"~"                     { ASCIIOP_RETURN(); }
     318"&"                     { ASCIIOP_RETURN(); }
     319"|"                     { ASCIIOP_RETURN(); }
     320"<"                     { ASCIIOP_RETURN(); }
     321">"                     { ASCIIOP_RETURN(); }
     322"="                     { ASCIIOP_RETURN(); }
     323"?"                     { ASCIIOP_RETURN(); }
     324
     325"++"                    { NAMEDOP_RETURN(ICR); }
     326"--"                    { NAMEDOP_RETURN(DECR); }
     327"=="                    { NAMEDOP_RETURN(EQ); }
     328"!="                    { NAMEDOP_RETURN(NE); }
     329"<<"                    { NAMEDOP_RETURN(LS); }
     330">>"                    { NAMEDOP_RETURN(RS); }
     331"<="                    { NAMEDOP_RETURN(LE); }
     332">="                    { NAMEDOP_RETURN(GE); }
     333"&&"                    { NAMEDOP_RETURN(ANDAND); }
     334"||"                    { NAMEDOP_RETURN(OROR); }
     335"->"                    { NAMEDOP_RETURN(ARROW); }
     336"+="                    { NAMEDOP_RETURN(PLUSassign); }
     337"-="                    { NAMEDOP_RETURN(MINUSassign); }
     338"*="                    { NAMEDOP_RETURN(MULTassign); }
     339"/="                    { NAMEDOP_RETURN(DIVassign); }
     340"%="                    { NAMEDOP_RETURN(MODassign); }
     341"&="                    { NAMEDOP_RETURN(ANDassign); }
     342"|="                    { NAMEDOP_RETURN(ORassign); }
     343"^="                    { NAMEDOP_RETURN(ERassign); }
     344"<<="                   { NAMEDOP_RETURN(LSassign); }
     345">>="                   { NAMEDOP_RETURN(RSassign); }
    331346
    332347        /* CFA, operator identifier */
    333 {op_unary}"?"           {IDENTIFIER_RETURN();}          /* unary */
    334 "?"({op_unary_pre_post}|"()"|"[?]") {IDENTIFIER_RETURN();}
    335 "?"{op_binary_over}"?"  {IDENTIFIER_RETURN();}          /* binary */
     348{op_unary}"?"           { IDENTIFIER_RETURN(); }        // unary
     349"?"({op_unary_pre_post}|"()"|"[?]") { IDENTIFIER_RETURN(); }
     350"?"{op_binary_over}"?"  { IDENTIFIER_RETURN(); }        // binary
    336351        /*
    337352          This rule handles ambiguous cases with operator identifiers, e.g., "int *?*?()", where the
    … …  
    365380                            // 1 or 2 character unary operator ?
    366381                            int i = yytext[1] == '?' ? 1 : 2;
    367                             yyless( i );                /* put back characters up to first '?' */
     382                            yyless( i );                // put back characters up to first '?'
    368383                            if ( i > 1 ) {
    369384                                NAMEDOP_RETURN( yytext[0] == '+' ? ICR : DECR );
    … …  
    374389
    375390        /* unknown characters */
    376 .                       {printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno);}
     391.                       { printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); }
    377392
    378393%%
Note: See TracChangeset for help on using the changeset viewer.