Index: src/Parser/ExpressionNode.cc
===================================================================
--- src/Parser/ExpressionNode.cc	(revision 03a4c732c41cec6ae90263ab98f94f3c2ea795c4)
+++ src/Parser/ExpressionNode.cc	(revision c5b55c44412a415b24dc720505dfe38f097da290)
@@ -10,6 +10,6 @@
 // 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,9 +65,11 @@
 
 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,6 +86,12 @@
 		} // 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,5 +164,4 @@
 	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,4 +202,5 @@
 			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,8 +212,10 @@
 			  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,4 +224,5 @@
 				scanbin( str2, v2 );
 			} // if
+#endif // __SIZEOF_INT128__
 			scanbin( str, v );
 			//printf( "%#llx %llu\n", v, v );
@@ -223,6 +234,7 @@
 				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,10 +249,9 @@
 					} // 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,6 +267,7 @@
 			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,10 +282,9 @@
 				} // 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
Index: tests/literals.cfa
===================================================================
--- tests/literals.cfa	(revision 03a4c732c41cec6ae90263ab98f94f3c2ea795c4)
+++ tests/literals.cfa	(revision c5b55c44412a415b24dc720505dfe38f097da290)
@@ -10,6 +10,6 @@
 // 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,9 +214,9 @@
 	-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,9 +225,11 @@
 	-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