Changeset 6840e7c for src/Parser/ExpressionNode.cc

Timestamp:

Oct 19, 2017, 12:01:04 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

837ce06

Parents:

b96ec83 (diff), a15b72c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into cleanup-dtors

File:

• src/Parser/ExpressionNode.cc (modified) (11 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 Sep 14 23:09:34 2017
-// Update Count     : 690
+// Last Modified On : Wed Sep 27 22:51:55 2017
+// Update Count     : 781
 //
 
@@ -60 +60 @@
 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
 
+static const char * lnthsInt[2][6] = {
+        { "int8_t", "int16_t", "int32_t", "int64_t", "size_t", },
+        { "uint8_t", "uint16_t", "uint32_t", "uint64_t", "size_t", }
+}; // lnthsInt
+
+static inline void checkLNInt( string & str, int & lnth, int & size ) {
+        string::size_type posn = str.find_first_of( "lL" ), start = posn;
+  if ( posn == string::npos ) return;
+        size = 4;                                                                                       // assume largest size
+        posn += 1;                                                                                      // advance to size
+        if ( str[posn] == '8' ) {                                                       // 8
+                lnth = 0;
+        } else if ( str[posn] == '1' ) {
+                posn += 1;
+                if ( str[posn] == '6' ) {                                               // 16
+                        lnth = 1;
+                } else {                                                                                // 128
+                        posn += 1;
+                        lnth = 5;
+                } // if
+        } else {
+                if ( str[posn] == '3' ) {                                               // 32
+                        lnth = 2;
+                } else if ( str[posn] == '6' ) {                                // 64
+                        lnth = 3;
+                } else {
+                        assertf( false, "internal error, bad integral length %s", str.c_str() );
+                } // if
+                posn += 1;
+        } // if
+        str.erase( start, posn - start + 1 );                           // remove length suffix
+} // checkLNInt
+
 static void sepNumeric( string & str, string & units ) {
         string::size_type posn = str.find_first_of( "`" );
@@ -69 +102 @@
 
 Expression * build_constantInteger( string & str ) {
-        static const BasicType::Kind kind[2][5] = {
+        static const BasicType::Kind kind[2][6] = {
                 // short (h) must be before char (hh)
-                { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
-                { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
+                { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt128, },
+                { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt128, },
         };
 
-        string units;                                                                           // units
+        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 => size_t
+        int size;                                                                                       // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128
+        int lnth = -1;                                                                          // literal length
+
         unsigned long long int v;                                                       // converted integral value
         size_t last = str.length() - 1;                                         // last character of constant
@@ -140 +175 @@
                         } // if
                         str.erase( last - size - 1, size + 1 );         // remove 'h'/"hh"
+                } else {                                                                                // suffix "ln" ?
+                        checkLNInt( str, lnth, size );
                 } // if
         } else if ( checkL( str[ last ] ) ) {                           // suffix 'l' ?
@@ -163 +200 @@
                 str.erase( last - size, size + 1 );                             // remove 'h'/"hh"
         } else if ( checkZ( str[last] ) ) {                                     // suffix 'z' ?
-                size = 5;
+                lnth = 4;
                 str.erase( last, 1 );                                                   // remove 'z'
-        } // if
-
+        } else {                                                                                        // suffix "ln" ?
+                checkLNInt( str, lnth, size );
+        } // if
+
+        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 ( Unsigned && size < 2 ) {                                           // less than int ?
-                // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which eliminates warnings for large values.
+        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] ) );
-        } else if ( size == 5 ) {                                                       // explicit cast to size_t
-                ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), "size_t", false ) );
+        } else if ( lnth != -1 ) {                                                      // explicit length ?
+                if ( lnth == 5 ) {                                                              // int128 ?
+                        size = 5;
+                        ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) );
+                } else {
+                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ) );
+                } // if
         } // if
   CLEANUP:
@@ -182 +228 @@
         return ret;
 } // build_constantInteger
+
+
+static inline void checkLNFloat( string & str, int & lnth, int & size ) {
+        string::size_type posn = str.find_first_of( "lL" ), start = posn;
+  if ( posn == string::npos ) return;
+        size = 2;                                                                                       // assume largest size
+        lnth = 0;
+        posn += 1;                                                                                      // advance to size
+        if ( str[posn] == '3' ) {                                                       // 32
+                size = 0;
+        } else if ( str[posn] == '6' ) {                                        // 64
+                size = 1;
+        } else if ( str[posn] == '8' || str[posn] == '1' ) { // 80, 128
+                size = 2;
+                if ( str[posn] == '1' ) posn += 1;
+        } else {
+                assertf( false, "internal error, bad floating point length %s", str.c_str() );
+        } // if
+        posn += 1;
+        str.erase( start, posn - start + 1 );                           // remove length suffix
+} // checkLNFloat
+
 
 Expression * build_constantFloat( string & str ) {
@@ -189 +257 @@
         };
 
-        string units;                                                                           // units
+        string units;
         sepNumeric( str, units );                                                       // separate constant from units
 
         bool complx = false;                                                            // real, complex
-        int size = 1;                                                                           // 0 => float, 1 => double (default), 2 => long double
+        int size = 1;                                                                           // 0 => float, 1 => double, 2 => long double
+        int lnth = -1;                                                                          // literal length
         // floating-point constant has minimum of 2 characters: 1. or .1
         size_t last = str.length() - 1;
@@ -211 +280 @@
         } else if ( checkL( str[last] ) ) {                                     // long double ?
                 size = 2;
+        } else {
+                size = 1;                                                                               // double (default)
+                checkLNFloat( str, lnth, size );
         } // if
         if ( ! complx && checkI( str[last - 1] ) ) {            // imaginary ?
@@ -216 +288 @@
         } // if
 
+        assert( 0 <= size && size < 3 );
         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 } );
@@ -321 +397 @@
 
 NameExpr * build_varref( const string * name ) {
-        NameExpr * expr = new NameExpr( *name, nullptr );
+        NameExpr * expr = new NameExpr( *name );
         delete name;
         return expr;
@@ -412 +488 @@
         list< Expression * > args;
         buildMoveList( expr_node, args );
-        return new UntypedExpr( maybeMoveBuild< Expression >(function), args, nullptr );
+        return new UntypedExpr( maybeMoveBuild< Expression >(function), args );
 } // build_func