Changes in src/Parser/ExpressionNode.cc [e612146c:beec62c]

File:

• src/Parser/ExpressionNode.cc (modified) (7 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 : Sun Sep  3 22:21:21 2017
-// Update Count     : 639
+// Last Modified On : Tue Sep 12 10:00:29 2017
+// Update Count     : 672
 //
 
@@ -49 +49 @@
 // type.
 
-extern const Type::Qualifiers noQualifiers;             // no qualifiers on constants
-
+extern const Type::Qualifiers noQualifiers;                             // no qualifiers on constants
+
+static inline bool checkH( char c ) { return c == 'h' || c == 'H'; }
+static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
+static inline bool checkZ( char c ) { return c == 'z' || c == 'Z'; }
 static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
-static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
 static inline bool checkF( char c ) { return c == 'f' || c == 'F'; }
 static inline bool checkD( char c ) { return c == 'd' || c == 'D'; }
@@ -67 +69 @@
 
 Expression * build_constantInteger( string & str ) {
-        static const BasicType::Kind kind[2][3] = {
-                { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
-                { BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
+        static const BasicType::Kind kind[2][5] = {
+                // 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 },
         };
 
@@ -76 +79 @@
 
         bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
-        int size;                                                                                       // 0 => int, 1 => long, 2 => long long
+        int size;                                                                                       // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => size_t
         unsigned long long int v;                                                       // converted integral value
         size_t last = str.length() - 1;                                         // last character of constant
         Expression * ret;
 
-        // ROB: what do we do with units on 0 and 1?
         // special constants
         if ( str == "0" ) {
@@ -107 +109 @@
 
         if ( v <= INT_MAX ) {                                                           // signed int
-                size = 0;
+                size = 2;
         } else if ( v <= UINT_MAX && ! dec ) {                          // unsigned int
-                size = 0;
+                size = 2;
                 Unsigned = true;                                                                // unsigned
         } else if ( v <= LONG_MAX ) {                                           // signed long int
-                size = 1;
+                size = 3;
         } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
-                size = 1;
+                size = 3;
                 Unsigned = true;                                                                // unsigned long int
         } else if ( v <= LLONG_MAX ) {                                          // signed long long int
-                size = 2;
+                size = 4;
         } else {                                                                                        // unsigned long long int
-                size = 2;
+                size = 4;
                 Unsigned = true;                                                                // unsigned long long int
         } // if
+
+        // At least one digit in integer constant, so safe to backup while looking for suffix.
 
         if ( checkU( str[last] ) ) {                                            // suffix 'u' ?
                 Unsigned = true;
-                if ( last > 0 && checkL( str[last - 1] ) ) {    // suffix 'l' ?
-                        size = 1;
-                        if ( last > 1 && checkL( str[last - 2] ) ) { // suffix 'll' ?
-                                size = 2;
+                if ( checkL( str[last - 1] ) ) {                                // suffix 'l' ?
+                        size = 3;
+                        if ( checkL( str[last - 2] ) ) {                        // suffix "ll" ?
+                                size = 4;
                         } // if
+                } else if ( checkH( str[last - 1] ) ) {                 // suffix 'h' ?
+                        size = 0;
+                        if ( checkH( str[last - 2] ) ) {                        // suffix "hh" ?
+                                size = 1;
+                        } // if
+                        str.erase( last - size - 1, size + 1 );         // remove 'h'/"hh"
                 } // if
         } else if ( checkL( str[ last ] ) ) {                           // suffix 'l' ?
-                size = 1;
-                if ( last > 0 && checkL( str[last - 1] ) ) {    // suffix 'll' ?
-                        size = 2;
-                        if ( last > 1 && checkU( str[last - 2] ) ) { // suffix 'u' ?
+                size = 3;
+                if ( checkL( str[last - 1] ) ) {                                // suffix 'll' ?
+                        size = 4;
+                        if ( checkU( str[last - 2] ) ) {                        // suffix 'u' ?
                                 Unsigned = true;
                         } // if
-                } else {
-                        if ( last > 0 && checkU( str[last - 1] ) ) { // suffix 'u' ?
+                } else if ( checkU( str[last - 1] ) ) {                 // suffix 'u' ?
+                        Unsigned = true;
+                } // if
+        } else if ( checkH( str[ last ] ) ) {                           // suffix 'h' ?
+                size = 0;
+                if ( checkH( str[last - 1] ) ) {                                // suffix "hh" ?
+                        size = 1;
+                        if ( checkU( str[last - 2] ) ) {                        // suffix 'u' ?
                                 Unsigned = true;
                         } // if
-                } // if
+                } else if ( checkU( str[last - 1] ) ) {                 // suffix 'u' ?
+                        Unsigned = true;
+                } // if
+                str.erase( last - size, size + 1 );                             // remove 'h'/"hh"
+        } else if ( checkZ( str[last] ) ) {                                     // suffix 'z' ?
+                size = 5;
+                str.erase( last, 1 );                                                   // remove 'z'
         } // if
 
         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.
+                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 ) );
+        } // if
   CLEANUP:
         if ( units.length() != 0 ) {
@@ -247 +275 @@
 } // build_constantStr
 
+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 );
+        Expression * ret = build_constantInteger( *new string( str.substr(1) ) );
+        delete &str;
+        return ret;
+} // build_field_name_FLOATING_FRACTIONconstant
+
+Expression * build_field_name_FLOATING_DECIMALconstant( const string & str ) {
+        if ( str[str.size()-1] != '.' ) throw SemanticError( "invalid tuple index " + str );
+        Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) );
+        delete &str;
+        return ret;
+} // build_field_name_FLOATING_DECIMALconstant
+
 Expression * build_field_name_FLOATINGconstant( const string & str ) {
         // str is of the form A.B -> separate at the . and return member expression
@@ -273 +315 @@
         return make_field_name_fraction_constants( fieldName, maybeMoveBuild< Expression >( fracts ) );
 } // build_field_name_fraction_constants
-
-Expression * build_field_name_REALFRACTIONconstant( const string & str ) {
-        if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( "invalid tuple index " + str );
-        Expression * ret = build_constantInteger( *new string( str.substr(1) ) );
-        delete &str;
-        return ret;
-} // build_field_name_REALFRACTIONconstant
-
-Expression * build_field_name_REALDECIMALconstant( const string & str ) {
-        if ( str[str.size()-1] != '.' ) throw SemanticError( "invalid tuple index " + str );
-        Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) );
-        delete &str;
-        return ret;
-} // build_field_name_REALDECIMALconstant
 
 NameExpr * build_varref( const string * name ) {