Changeset c5b55c4

Timestamp:

Aug 20, 2020, 1:56:08 PM (5 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

013b028

Parents:

03a4c73

Message:

fix missing 'u' suffix for length suffix, change L128 constants to always generate hexadecimal components

Files:

• src/Parser/ExpressionNode.cc (modified) (11 diffs)
• tests/literals.cfa (modified) (3 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 : Wed Jul 15 08:24:08 2020
-// Update Count     : 1046
+// Last Modified On : Thu Aug 20 11:52:59 2020
+// Update Count     : 1075
 //
 
@@ -65 +65 @@
 
 void lnthSuffix( string & str, int & type, int & ltype ) {
+        // 'u' can appear before or after length suffix
         string::size_type posn = str.find_last_of( "lL" );
 
         if ( posn == string::npos ) return;                                     // no suffix
-        if ( posn == str.length() - 1 ) { type = 3; return; } // no length => long
-
+        size_t end = str.length() - 1;
+        if ( posn == end ) { type = 3; return; }                        // no length after 'l' => long
+        
         string::size_type next = posn + 1;                                      // advance to length
         if ( str[next] == '3' ) {                                                       // 32
@@ -84 +86 @@
                 } // if
         } // if
-        // remove "lL" for these cases because it may not imply long
-        str.erase( posn );                                                                      // remove length suffix and "uU"
+
+        char fix = '\0';
+        if ( str[end] == 'u' || str[end] == 'U' ) fix = str[end]; // ends with 'uU' ?
+        str.erase( posn );                                                                      // remove length suffix and possibly uU
+        if ( type == 5 ) {                                                                      // L128 does not need uU
+                end = str.length() - 1;
+                if ( str[end] == 'u' || str[end] == 'U' ) str.erase( end ); // ends with 'uU' ? remove
+        } else if ( fix != '\0' ) str += fix;                           // put 'uU' back if removed
 } // lnthSuffix
 
@@ -156 +164 @@
         if ( isdigit( str[str.length() - 1] ) ) {                       // no suffix ?
                 lnthSuffix( str, type, ltype );                                 // could have length suffix
-                if ( type == 5 && Unsigned ) str.erase( str.length() - 1 ); // L128 and terminating "uU" ?
         } else {
                 // At least one digit in integer constant, so safe to backup while looking for suffix.
@@ -195 +202 @@
                         if ( type < 5 ) {                                                       // not L128 ?
                                 sscanf( (char *)str.c_str(), "%llx", &v );
+#if defined(__SIZEOF_INT128__)
                         } else {                                                                        // hex int128 constant
                                 unsigned int len = str.length();
@@ -204 +212 @@
                           FHEX1: ;
                                 sscanf( (char *)str.c_str(), "%llx", &v );
+#endif // __SIZEOF_INT128__
                         } // if
                         //printf( "%llx %llu\n", v, v );
                 } else if ( checkB( str[1] ) ) {                                // binary constant ?
                         unsigned int len = str.length();
+#if defined(__SIZEOF_INT128__)
                         if ( type == 5 && len > 2 + 64 ) {
                                 if ( len > 2 + 64 + 64 ) SemanticError( yylloc, "128-bit binary constant to large " + str );
@@ -214 +224 @@
                                 scanbin( str2, v2 );
                         } // if
+#endif // __SIZEOF_INT128__
                         scanbin( str, v );
                         //printf( "%#llx %llu\n", v, v );
@@ -223 +234 @@
                                 unsigned int len = str.length();
                                 if ( len > 1 + 43 || (len == 1 + 43 && str[0] > '3') ) SemanticError( yylloc, "128-bit octal constant to large " + str );
+                                char buf[32];
                                 if ( len <= 1 + 21 ) {                                  // value < 21 octal digitis
-                                        sscanf( (char *)str.c_str(), "%llo", &v ); // leave value in octal
+                                        sscanf( (char *)str.c_str(), "%llo", &v );
                                 } else {
                                         sscanf( &str[len - 21], "%llo", &v );
@@ -237 +249 @@
                                         } // if
                                         v = val >> 64; v2 = (uint64_t)val;      // replace octal constant with 2 hex constants
-                                        char buf[32];
                                         sprintf( buf, "%#llx", v2 );
                                         str2 = buf;
-                                        sprintf( buf, "%#llx", v );
-                                        str = buf;
                                 } // if
+                                sprintf( buf, "%#llx", v );
+                                str = buf;
 #endif // __SIZEOF_INT128__
                         } // if
@@ -256 +267 @@
                         if ( str.length() == 39 && str > (Unsigned ? "340282366920938463463374607431768211455" : "170141183460469231731687303715884105727") )
                                 SemanticError( yylloc, "128-bit decimal constant to large " + str );
+                        char buf[32];
                         if ( len <= 19 ) {                                                      // value < 19 decimal digitis
-                                sscanf( (char *)str.c_str(), "%llu", &v ); // leave value in decimal
+                                sscanf( (char *)str.c_str(), "%llu", &v );
                         } else {
                                 sscanf( &str[len - 19], "%llu", &v );
@@ -270 +282 @@
                                 } // if
                                 v = val >> 64; v2 = (uint64_t)val;              // replace decimal constant with 2 hex constants
-                                char buf[32];
                                 sprintf( buf, "%#llx", v2 );
                                 str2 = buf;
-                                sprintf( buf, "%#llx", v );
-                                str = buf;
                         } // if
+                        sprintf( buf, "%#llx", v );
+                        str = buf;
 #endif // __SIZEOF_INT128__
                 } // if

tests/literals.cfa ¶

@@ -10 +10 @@
 // Created On       : Sat Sep  9 16:34:38 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb 12 08:07:39 2019
-// Update Count     : 224
+// Last Modified On : Thu Aug 20 13:51:12 2020
+// Update Count     : 225
 //
 
@@ -214 +214 @@
         -01234567_l8;  -01234567_l16;  -01234567_l32;  -01234567_l64;  -01234567_l8u;  -01234567_ul16;  -01234567_l32u;  -01234567_ul64;
 
-#ifdef __LP64__ // 64-bit processor
+#if defined( __SIZEOF_INT128__ )
         01234567_l128;   01234567_ul128;
         +01234567_l128;  +01234567_ul128;
         -01234567_l128;  -01234567_ul128;
-#endif // __LP64__
+#endif // __SIZEOF_INT128__
 
         // decimal
@@ -225 +225 @@
         -1234567890L8;  -1234567890L16;  -1234567890l32;  -1234567890l64;  -1234567890UL8;  -1234567890L16U;  -1234567890Ul32;  -1234567890l64u;
 
-#ifdef __LP64__ // 64-bit processor
+#if defined( __SIZEOF_INT128__ )
         1234567890l128;   1234567890l128u;
         +1234567890l128;  +1234567890l128u;
         -1234567890l128;  -1234567890l128u;
-#endif // __LP64__
+    1234567890123456789_L128u; 1234567890123456789_L128u;
+        18446708753438544741_l64u; 18446708753438544741_Ul64;
+#endif // __SIZEOF_INT128__
 
         // hexadecimal