Changes in src/Parser/ExpressionNode.cc [bf4b4cf:6e3eaa57]

File:

• src/Parser/ExpressionNode.cc (modified) (13 diffs)

src/Parser/ExpressionNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Sep 26 11:23:36 2017
-// Update Count     : 780
+// Last Modified On : Mon Jun  4 21:24:45 2018
+// Update Count     : 802
 //
 
@@ -58 +58 @@
 static inline bool checkD( char c ) { return c == 'd' || c == 'D'; }
 static inline bool checkI( char c ) { return c == 'i' || c == 'I'; }
+static inline bool checkB( char c ) { return c == 'b' || c == 'B'; }
 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
 
@@ -93 +94 @@
 } // checkLNInt
 
-static void sepNumeric( string & str, string & units ) {
-        string::size_type posn = str.find_first_of( "`" );
-        if ( posn != string::npos ) {
-                units = "?" + str.substr( posn );                               // extract units
-                str.erase( posn );                                                              // remove units
-        } // if
-} // sepNumeric
-
 Expression * build_constantInteger( string & str ) {
         static const BasicType::Kind kind[2][6] = {
@@ -108 +101 @@
         };
 
-        string units;
-        sepNumeric( str, units );                                                       // separate constant from units
-
         bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
         int size;                                                                                       // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128
@@ -116 +106 @@
 
         unsigned long long int v;                                                       // converted integral value
-        size_t last = str.length() - 1;                                         // last character of constant
+        size_t last = str.length() - 1;                                         // last subscript of constant
         Expression * ret;
 
@@ -129 +119 @@
         } // if
 
-        if ( str[0] == '0' ) {                                                          // octal/hex constant ?
+        // Cannot be "0"
+
+        if ( str[0] == '0' ) {                                                          // radix character ?
                 dec = false;
-                if ( last != 0 && checkX( str[1] ) ) {                  // hex constant ?
+                if ( checkX( str[1] ) ) {                                               // hex constant ?
                         sscanf( (char *)str.c_str(), "%llx", &v );
+                        //printf( "%llx %llu\n", v, v );
+                } else if ( checkB( str[1] ) ) {                                // binary constant ?
+                        v = 0;
+                        for ( unsigned int i = 2;; i += 1 ) {           // compute value
+                                if ( str[i] == '1' ) v |= 1;
+                          if ( i == last ) break;
+                                v <<= 1;
+                        } // for
                         //printf( "%llx %llu\n", v, v );
                 } else {                                                                                // octal constant
@@ -207 +207 @@
 
         assert( 0 <= size && size < 6 );
+        // Constant type is correct for overload resolving.
         ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) );
-        if ( size < 2 ) {                                                                       // hh or h, less than int ?
+        if ( Unsigned && size < 2 ) {                                           // hh or h, less than int ?
                 // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which unfortunately eliminates warnings for large values.
-                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) );
+                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ), false );
         } else if ( lnth != -1 ) {                                                      // explicit length ?
                 if ( lnth == 5 ) {                                                              // int128 ?
                         size = 5;
-                        ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) );
+                        ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ), false );
                 } else {
-                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ) );
+                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ), false );
                 } // if
         } // if
   CLEANUP:
-        if ( units.length() != 0 ) {
-                ret = new UntypedExpr( new NameExpr( units ), { ret } );
-        } // if
 
         delete &str;                                                                            // created by lex
@@ -256 +254 @@
         };
 
-        string units;
-        sepNumeric( str, units );                                                       // separate constant from units
-
         bool complx = false;                                                            // real, complex
         int size = 1;                                                                           // 0 => float, 1 => double, 2 => long double
@@ -290 +285 @@
         Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][size] ), str, v ) );
         if ( lnth != -1 ) {                                                                     // explicit length ?
-                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][size] ) );
-        } // if
-        if ( units.length() != 0 ) {
-                ret = new UntypedExpr( new NameExpr( units ), { ret } );
+                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][size] ), false );
         } // if
 
@@ -322 +314 @@
 
 Expression * build_constantStr( string & str ) {
+        assert( str.length() > 0 );
         string units;                                                                           // units
         sepString( str, units, '"' );                                           // separate constant from units
@@ -355 +348 @@
 
 Expression * build_field_name_FLOATING_FRACTIONconstant( const string & str ) {
-        if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( "invalid tuple index " + str );
+        if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) SemanticError( yylloc, "invalid tuple index " + str );
         Expression * ret = build_constantInteger( *new string( str.substr(1) ) );
         delete &str;
@@ -362 +355 @@
 
 Expression * build_field_name_FLOATING_DECIMALconstant( const string & str ) {
-        if ( str[str.size()-1] != '.' ) throw SemanticError( "invalid tuple index " + str );
+        if ( str[str.size()-1] != '.' ) SemanticError( yylloc, "invalid tuple index " + str );
         Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) );
         delete &str;
@@ -416 +409 @@
         if ( dynamic_cast< VoidType * >( targetType ) ) {
                 delete targetType;
-                return new CastExpr( maybeMoveBuild< Expression >(expr_node) );
+                return new CastExpr( maybeMoveBuild< Expression >(expr_node), false );
         } else {
-                return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType );
+                return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType, false );
         } // if
 } // build_cast
+
+Expression * build_keyword_cast( KeywordCastExpr::Target target, ExpressionNode * expr_node ) {
+        return new KeywordCastExpr( maybeMoveBuild< Expression >(expr_node), target );
+}
 
 Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) {