Changes in src/Parser/ExpressionNode.cc [9a705dc8:68f9c43]

File:

• src/Parser/ExpressionNode.cc (modified) (8 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 : Thu Mar 22 11:57:39 2018
-// Update Count     : 801
+// Last Modified On : Sat Mar  3 18:22:33 2018
+// Update Count     : 796
 //
 
@@ -94 +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] = {
@@ -100 +108 @@
                 { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt128, },
         };
+
+        string units;
+        sepNumeric( str, units );                                                       // separate constant from units
 
         bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
@@ -211 +222 @@
         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] ), false );
+                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) );
         } else if ( lnth != -1 ) {                                                      // explicit length ?
                 if ( lnth == 5 ) {                                                              // int128 ?
                         size = 5;
-                        ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ), false );
+                        ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) );
                 } else {
-                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ), false );
+                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ) );
                 } // if
         } // if
   CLEANUP:
+        if ( units.length() != 0 ) {
+                ret = new UntypedExpr( new NameExpr( units ), { ret } );
+        } // if
 
         delete &str;                                                                            // created by lex
@@ -254 +268 @@
         };
 
+        string units;
+        sepNumeric( str, units );                                                       // separate constant from units
+
         bool complx = false;                                                            // real, complex
         int size = 1;                                                                           // 0 => float, 1 => double, 2 => long double
@@ -285 +302 @@
         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] ), false );
+                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][size] ) );
+        } // if
+        if ( units.length() != 0 ) {
+                ret = new UntypedExpr( new NameExpr( units ), { ret } );
         } // if
 
@@ -407 +427 @@
         Type * targetType = maybeMoveBuildType( decl_node );
         if ( dynamic_cast< VoidType * >( targetType ) ) {
-                delete targetType;
-                return new CastExpr( maybeMoveBuild< Expression >(expr_node), false );
+                return new CastExpr( maybeMoveBuild< Expression >(expr_node) );
         } else {
-                return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType, false );
+                return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType );
         } // 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 ) {
@@ -435 +450 @@
 
 Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member ) {
-        Expression * ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() );
-        delete member;
-        return ret;
+        return new UntypedOffsetofExpr{ maybeMoveBuildType( decl_node ), member->get_name() };
 } // build_offsetOf