Index: src/Parser/ExpressionNode.cc
===================================================================
--- src/Parser/ExpressionNode.cc	(revision db70fe486deb21f8bc7f6dec306f1c81a12695b0)
+++ src/Parser/ExpressionNode.cc	(revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33)
@@ -10,6 +10,6 @@
 // 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 : Tue Sep 26 11:23:36 2017
+// Update Count     : 780
 //
 
@@ -60,4 +60,37 @@
 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,15 +102,17 @@
 
 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,4 +175,6 @@
 			} // 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,14 +200,22 @@
 		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 );
 	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 ( 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,4 +227,26 @@
 	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,9 +256,10 @@
 	};
 
-	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,4 +279,7 @@
 	} 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,5 +287,9 @@
 	} // 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 } );
