Changes in src/Parser/lex.ll [b6ad601:553772b]

File:

• src/Parser/lex.ll (modified) (7 diffs)

src/Parser/lex.ll

@@ -10 +10 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Thu Nov  1 20:57:35 2018
- * Update Count     : 687
+ * Last Modified On : Wed May 15 21:25:27 2019
+ * Update Count     : 708
  */
 
@@ -39 +39 @@
 using namespace std;
 
+#include "config.h"                                                                             // configure info
 #include "ParseNode.h"
 #include "TypedefTable.h"
@@ -59 +60 @@
 #define IDENTIFIER_RETURN()     RETURN_VAL( typedefTable.isKind( yytext ) )
 #define ATTRIBUTE_RETURN()      RETURN_VAL( ATTR_IDENTIFIER )
+
+#ifdef HAVE_KEYWORDS_FLOATXX                                                            // GCC >= 7 => keyword, otherwise typedef
+#define FLOATXX(v) KEYWORD_RETURN(v);
+#else
+#define FLOATXX(v) IDENTIFIER_RETURN(); 
+#endif // HAVE_KEYWORDS_FLOATXX
 
 void rm_underscore() {
@@ -92 +99 @@
 hex_quad {hex}("_"?{hex}){3}
 size_opt (8|16|32|64|128)?
-length ("ll"|"LL"|[lL]{size_opt})|("hh"|"HH"|[hH])
-integer_suffix_opt ("_"?(([uU]({length}?[iI]?)|([iI]{length}))|([iI]({length}?[uU]?)|([uU]{length}))|({length}([iI]?[uU]?)|([uU][iI]))|[zZ]))?
+                                // CFA: explicit l8/l16/l32/l64/l128, char 'hh', short 'h', int 'n'
+length ("ll"|"LL"|[lL]{size_opt})|("hh"|"HH"|[hHnN])
+                                // CFA: size_t 'z', pointer 'p', which define a sign and length
+integer_suffix_opt ("_"?(([uU]({length}?[iI]?)|([iI]{length}))|([iI]({length}?[uU]?)|([uU]{length}))|({length}([iI]?[uU]?)|([uU][iI]))|[zZ]|[pP]))?
 
 octal_digits ({octal})|({octal}({octal}|"_")*{octal})
@@ -112 +121 @@
                                 // GCC: D (double) and iI (imaginary) suffixes, and DL (long double)
 exponent "_"?[eE]"_"?[+-]?{decimal_digits}
-floating_size 32|64|80|128
-floating_length ([fFdDlL]|[lL]{floating_size})
+floating_size 16|32|32x|64|64x|80|128|128x
+floating_length ([fFdDlLwWqQ]|[fF]{floating_size})
 floating_suffix ({floating_length}?[iI]?)|([iI]{floating_length})
 floating_suffix_opt ("_"?({floating_suffix}|"DL"))?
@@ -217 +226 @@
 char                    { KEYWORD_RETURN(CHAR); }
 choose                  { KEYWORD_RETURN(CHOOSE); }                             // CFA
+coerce                  { KEYWORD_RETURN(COERCE); }                             // CFA
 _Complex                { KEYWORD_RETURN(COMPLEX); }                    // C99
 __complex               { KEYWORD_RETURN(COMPLEX); }                    // GCC
@@ -240 +250 @@
 finally                 { KEYWORD_RETURN(FINALLY); }                    // CFA
 float                   { KEYWORD_RETURN(FLOAT); }
-_Float32                { KEYWORD_RETURN(FLOAT); }                              // GCC
-_Float32x               { KEYWORD_RETURN(FLOAT); }                              // GCC
-_Float64                { KEYWORD_RETURN(DOUBLE); }                             // GCC
-_Float64x               { KEYWORD_RETURN(DOUBLE); }                             // GCC
-__float80               { KEYWORD_RETURN(FLOAT80); }                    // GCC
-float80                 { KEYWORD_RETURN(FLOAT80); }                    // GCC
-_Float128               { KEYWORD_RETURN(FLOAT128); }                   // GCC
-_Float128x              { KEYWORD_RETURN(FLOAT128); }                   // GCC
-__float128              { KEYWORD_RETURN(FLOAT128); }                   // GCC
-float128                { KEYWORD_RETURN(FLOAT128); }                   // GCC
+__float80               { KEYWORD_RETURN(uuFLOAT80); }                  // GCC
+float80                 { KEYWORD_RETURN(uuFLOAT80); }                  // GCC
+__float128              { KEYWORD_RETURN(uuFLOAT128); }                 // GCC
+float128                { KEYWORD_RETURN(uuFLOAT128); }                 // GCC
+_Float16                { FLOATXX(uFLOAT16); }                                  // GCC
+_Float32                { FLOATXX(uFLOAT32); }                                  // GCC
+_Float32x               { FLOATXX(uFLOAT32X); }                                 // GCC
+_Float64                { FLOATXX(uFLOAT64); }                                  // GCC
+_Float64x               { FLOATXX(uFLOAT64X); }                                 // GCC
+_Float128               { FLOATXX(uFLOAT128); }                                 // GCC
+_Float128x              { FLOATXX(uFLOAT128); }                                 // GCC
 for                             { KEYWORD_RETURN(FOR); }
 forall                  { KEYWORD_RETURN(FORALL); }                             // CFA
 fortran                 { KEYWORD_RETURN(FORTRAN); }
 ftype                   { KEYWORD_RETURN(FTYPE); }                              // CFA
+generator               { KEYWORD_RETURN(GENERATOR); }                  // CFA
 _Generic                { KEYWORD_RETURN(GENERIC); }                    // C11
 goto                    { KEYWORD_RETURN(GOTO); }