Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision d48e529cc868a651ee3760fbd3cf7b1570a205b4)
+++ src/Parser/DeclarationNode.cc	(revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33)
@@ -9,7 +9,7 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 12:34:05 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Thr Aug 10 17:02:00 2017
-// Update Count     : 1021
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Sep 23 18:16:48 2017
+// Update Count     : 1024
 //
 
@@ -40,6 +40,6 @@
 using namespace std;
 
-// These must remain in the same order as the corresponding DeclarationNode enumerations.
-const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicTypeNames" };
+// These must harmonize with the corresponding DeclarationNode enumerations.
+const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "int128", "float80", "float128", "NoBasicTypeNames" };
 const char * DeclarationNode::complexTypeNames[] = { "_Complex", "_Imaginary", "NoComplexTypeNames" };
 const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" };
Index: src/Parser/ExpressionNode.cc
===================================================================
--- src/Parser/ExpressionNode.cc	(revision d48e529cc868a651ee3760fbd3cf7b1570a205b4)
+++ 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 } );
Index: src/Parser/ParseNode.h
===================================================================
--- src/Parser/ParseNode.h	(revision d48e529cc868a651ee3760fbd3cf7b1570a205b4)
+++ src/Parser/ParseNode.h	(revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Sep 14 23:09:39 2017
-// Update Count     : 815
+// Last Modified On : Sat Sep 23 18:11:22 2017
+// Update Count     : 821
 //
 
@@ -47,6 +47,4 @@
 #define YYLTYPE_IS_DECLARED 1 /* alert the parser that we have our own definition */
 
-extern char * yyfilename;
-extern int yylineno;
 extern YYLTYPE yylloc;
 
@@ -197,18 +195,18 @@
 class DeclarationNode : public ParseNode {
   public:
-	enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
+	// These enumerations must harmonize with their names.
+	enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, Int128, Float80, Float128, NoBasicType };
+	static const char * basicTypeNames[];
 	enum ComplexType { Complex, Imaginary, NoComplexType };
+	static const char * complexTypeNames[];
 	enum Signedness { Signed, Unsigned, NoSignedness };
+	static const char * signednessNames[];
 	enum Length { Short, Long, LongLong, NoLength };
+	static const char * lengthNames[];
 	enum Aggregate { Struct, Union, Trait, Coroutine, Monitor, Thread, NoAggregate };
+	static const char * aggregateNames[];
 	enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass };
+	static const char * typeClassNames[];
 	enum BuiltinType { Valist, Zero, One, NoBuiltinType };
-
-	static const char * basicTypeNames[];
-	static const char * complexTypeNames[];
-	static const char * signednessNames[];
-	static const char * lengthNames[];
-	static const char * aggregateNames[];
-	static const char * typeClassNames[];
 	static const char * builtinTypeNames[];
 
Index: src/Parser/TypeData.cc
===================================================================
--- src/Parser/TypeData.cc	(revision d48e529cc868a651ee3760fbd3cf7b1570a205b4)
+++ src/Parser/TypeData.cc	(revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Sep  1 23:13:38 2017
-// Update Count     : 569
+// Last Modified On : Mon Sep 25 18:33:41 2017
+// Update Count     : 587
 //
 
@@ -98,4 +98,5 @@
 } // TypeData::TypeData
 
+
 TypeData::~TypeData() {
 	delete base;
@@ -161,4 +162,5 @@
 	} // switch
 } // TypeData::~TypeData
+
 
 TypeData * TypeData::clone() const {
@@ -235,4 +237,5 @@
 } // TypeData::clone
 
+
 void TypeData::print( ostream &os, int indent ) const {
 	for ( int i = 0; i < Type::NumTypeQualifier; i += 1 ) {
@@ -398,4 +401,5 @@
 	} // switch
 } // TypeData::print
+
 
 template< typename ForallList >
@@ -430,5 +434,6 @@
 		} // if
 	} // for
-}
+} // buildForall
+
 
 Type * typebuild( const TypeData * td ) {
@@ -477,4 +482,5 @@
 } // typebuild
 
+
 TypeData * typeextractAggregate( const TypeData * td, bool toplevel ) {
 	TypeData * ret = nullptr;
@@ -504,8 +510,14 @@
 } // typeextractAggregate
 
+
 Type::Qualifiers buildQualifiers( const TypeData * td ) {
 	return td->qualifiers;
 } // buildQualifiers
 
+
+static string genTSError( string msg, DeclarationNode::BasicType basictype ) {
+	throw SemanticError( string( "invalid type specifier \"" ) + msg + "\" for type \"" + DeclarationNode::basicTypeNames[basictype] + "\"." );
+} // genTSError
+
 Type * buildBasicType( const TypeData * td ) {
 	BasicType::Kind ret;
@@ -513,8 +525,10 @@
 	switch ( td->basictype ) {
 	  case DeclarationNode::Void:
-		if ( td->signedness != DeclarationNode::NoSignedness && td->length != DeclarationNode::NoLength ) {
-			throw SemanticError( "invalid type specifier \"void\" in type: ", td );
-		} // if
-
+		if ( td->signedness != DeclarationNode::NoSignedness ) {
+			genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
+		} // if
+		if ( td->length != DeclarationNode::NoLength ) {
+			genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
+		} // if
 		return new VoidType( buildQualifiers( td ) );
 		break;
@@ -522,8 +536,8 @@
 	  case DeclarationNode::Bool:
 		if ( td->signedness != DeclarationNode::NoSignedness ) {
-			throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td );
+			genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
 		} // if
 		if ( td->length != DeclarationNode::NoLength ) {
-			throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
+			genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
 		} // if
 
@@ -538,5 +552,5 @@
 
 		if ( td->length != DeclarationNode::NoLength ) {
-			throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
+			genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
 		} // if
 
@@ -557,5 +571,14 @@
 		break;
 
+	  case DeclarationNode::Int128:
+		ret = td->signedness == 1 ? BasicType::UnsignedInt128 : BasicType::SignedInt128;
+		if ( td->length != DeclarationNode::NoLength ) {
+			genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
+		} // if
+		break;
+
 	  case DeclarationNode::Float:
+	  case DeclarationNode::Float80:
+	  case DeclarationNode::Float128:
 	  case DeclarationNode::Double:
 	  case DeclarationNode::LongDouble:					// not set until below
@@ -568,11 +591,11 @@
 	  FloatingPoint: ;
 		if ( td->signedness != DeclarationNode::NoSignedness ) {
-			throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td );
+			genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
 		} // if
 		if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) {
-			throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
+			genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
 		} // if
 		if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) {
-			throw SemanticError( "invalid type specifier \"long\" in type: ", td );
+			genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
 		} // if
 		if ( td->length == DeclarationNode::Long ) {
@@ -593,5 +616,5 @@
 		goto Integral;
 	  default:
-	  	assert(false);
+	  	assertf( false, "unknown basic type" );
 		return nullptr;
 	} // switch
@@ -601,4 +624,5 @@
 	return bt;
 } // buildBasicType
+
 
 PointerType * buildPointer( const TypeData * td ) {
@@ -612,4 +636,5 @@
 	return pt;
 } // buildPointer
+
 
 ArrayType * buildArray( const TypeData * td ) {
@@ -626,4 +651,5 @@
 } // buildArray
 
+
 ReferenceType * buildReference( const TypeData * td ) {
 	ReferenceType * rt;
@@ -637,4 +663,5 @@
 } // buildReference
 
+
 AggregateDecl * buildAggregate( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
 	assert( td->kind == TypeData::Aggregate );
@@ -665,4 +692,5 @@
 	return at;
 } // buildAggregate
+
 
 ReferenceToType * buildComAggInst( const TypeData * type, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
@@ -722,4 +750,5 @@
 } // buildAggInst
 
+
 ReferenceToType * buildAggInst( const TypeData * td ) {
 	assert( td->kind == TypeData::AggregateInst );
@@ -761,4 +790,5 @@
 } // buildAggInst
 
+
 NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage ) {
 	assert( td->kind == TypeData::Symbolic );
@@ -775,4 +805,5 @@
 } // buildSymbolic
 
+
 EnumDecl * buildEnum( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
 	assert( td->kind == TypeData::Enum );
@@ -790,4 +821,5 @@
 } // buildEnum
 
+
 TypeInstType * buildSymbolicInst( const TypeData * td ) {
 	assert( td->kind == TypeData::SymbolicInst );
@@ -797,4 +829,5 @@
 	return ret;
 } // buildSymbolicInst
+
 
 TupleType * buildTuple( const TypeData * td ) {
@@ -807,4 +840,5 @@
 } // buildTuple
 
+
 TypeofType * buildTypeof( const TypeData * td ) {
 	assert( td->kind == TypeData::Typeof );
@@ -813,4 +847,5 @@
 	return new TypeofType( buildQualifiers( td ), td->typeexpr->build() );
 } // buildTypeof
+
 
 Declaration * buildDecl( const TypeData * td, const string &name, Type::StorageClasses scs, Expression * bitfieldWidth, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, Expression *asmName, Initializer * init, std::list< Attribute * > attributes ) {
@@ -836,4 +871,5 @@
 	return nullptr;
 } // buildDecl
+
 
 FunctionType * buildFunction( const TypeData * td ) {
@@ -857,4 +893,5 @@
 	return ft;
 } // buildFunction
+
 
 // Transform KR routine declarations into C99 routine declarations:
Index: src/Parser/lex.ll
===================================================================
--- src/Parser/lex.ll	(revision d48e529cc868a651ee3760fbd3cf7b1570a205b4)
+++ src/Parser/lex.ll	(revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33)
@@ -10,6 +10,6 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Sun Sep 10 22:29:15 2017
- * Update Count     : 620
+ * Last Modified On : Sat Sep 23 17:29:28 2017
+ * Update Count     : 632
  */
 
@@ -93,5 +93,6 @@
 				// numeric constants, CFA: '_' in constant
 hex_quad {hex}("_"?{hex}){3}
-length ("ll"|"LL"|[lL])|("hh"|"HH"|[hH])
+size_opt (8|16|32|64|128)?
+length ("ll"|"LL"|[lL]{size_opt})|("hh"|"HH"|[hH])
 integer_suffix_opt ("_"?(([uU]({length}?[iI]?)|([iI]{length}))|([iI]({length}?[uU]?)|([uU]{length}))|({length}([iI]?[uU]?)|([uU][iI]))|[zZ]))?{user_suffix_opt}
 
@@ -109,5 +110,7 @@
 				// GCC: D (double) and iI (imaginary) suffixes, and DL (long double)
 exponent "_"?[eE]"_"?[+-]?{decimal_digits}
-floating_suffix ([fFdDlL]?[iI]?)|([iI][lLfFdD])
+floating_size 32|64|80|128
+floating_length ([fFdDlL]|[lL]{floating_size})
+floating_suffix ({floating_length}?[iI]?)|([iI]{floating_length})
 floating_suffix_opt ("_"?({floating_suffix}|"DL"))?{user_suffix_opt}
 decimal_digits ({decimal})|({decimal}({decimal}|"_")*{decimal})
@@ -234,5 +237,8 @@
 finally			{ KEYWORD_RETURN(FINALLY); }			// CFA
 float			{ KEYWORD_RETURN(FLOAT); }
-__float128		{ KEYWORD_RETURN(FLOAT); }				// GCC
+__float80		{ KEYWORD_RETURN(FLOAT80); }			// GCC
+float80			{ KEYWORD_RETURN(FLOAT80); }			// GCC
+__float128		{ KEYWORD_RETURN(FLOAT128); }			// GCC
+float128		{ KEYWORD_RETURN(FLOAT128); }			// GCC
 for				{ KEYWORD_RETURN(FOR); }
 forall			{ KEYWORD_RETURN(FORALL); }				// CFA
@@ -249,6 +255,6 @@
 __inline__		{ KEYWORD_RETURN(INLINE); }				// GCC
 int				{ KEYWORD_RETURN(INT); }
-__int128		{ KEYWORD_RETURN(INT); }				// GCC
-__int128_t		{ KEYWORD_RETURN(INT); }				// GCC
+__int128		{ KEYWORD_RETURN(INT128); }				// GCC
+int128			{ KEYWORD_RETURN(INT128); }				// GCC
 __label__		{ KEYWORD_RETURN(LABEL); }				// GCC
 long			{ KEYWORD_RETURN(LONG); }
@@ -285,5 +291,4 @@
 __typeof		{ KEYWORD_RETURN(TYPEOF); }				// GCC
 __typeof__		{ KEYWORD_RETURN(TYPEOF); }				// GCC
-__uint128_t		{ KEYWORD_RETURN(INT); }				// GCC
 union			{ KEYWORD_RETURN(UNION); }
 unsigned		{ KEYWORD_RETURN(UNSIGNED); }
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision d48e529cc868a651ee3760fbd3cf7b1570a205b4)
+++ src/Parser/parser.yy	(revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33)
@@ -10,6 +10,6 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Sep 14 23:07:12 2017
-// Update Count     : 2815
+// Last Modified On : Sat Sep 23 17:43:15 2017
+// Update Count     : 2829
 //
 
@@ -43,5 +43,5 @@
 #define YYDEBUG_LEXER_TEXT (yylval)						// lexer loads this up each time
 #define YYDEBUG 1										// get the pretty debugging code to compile
-#define YYERROR_VERBOSE
+#define YYERROR_VERBOSE									// more information in syntax errors
 
 #undef __GNUC_MINOR__
@@ -117,25 +117,22 @@
 bool forall = false;									// aggregate have one or more forall qualifiers ?
 
-# define YYLLOC_DEFAULT(Cur, Rhs, N)                            \
-do                                                              \
-	if (N) {                                                      \
-		(Cur).first_line   = YYRHSLOC(Rhs, 1).first_line;           \
-		(Cur).first_column = YYRHSLOC(Rhs, 1).first_column;         \
-		(Cur).last_line    = YYRHSLOC(Rhs, N).last_line;            \
-		(Cur).last_column  = YYRHSLOC(Rhs, N).last_column;          \
-		(Cur).filename     = YYRHSLOC(Rhs, 1).filename;             \
-	} else {                                                      \
-		(Cur).first_line   = (Cur).last_line   =                    \
-			YYRHSLOC(Rhs, 0).last_line;                               \
-		(Cur).first_column = (Cur).last_column =                    \
-			YYRHSLOC(Rhs, 0).last_column;                             \
-		(Cur).filename     = YYRHSLOC(Rhs, 0).filename;             \
-	}                                                             \
-while (0)
+// https://www.gnu.org/software/bison/manual/bison.html#Location-Type
+#define YYLLOC_DEFAULT(Cur, Rhs, N)												\
+if ( N ) {																		\
+	(Cur).first_line   = YYRHSLOC( Rhs, 1 ).first_line;							\
+	(Cur).first_column = YYRHSLOC( Rhs, 1 ).first_column;						\
+	(Cur).last_line    = YYRHSLOC( Rhs, N ).last_line;							\
+	(Cur).last_column  = YYRHSLOC( Rhs, N ).last_column;						\
+	(Cur).filename     = YYRHSLOC( Rhs, 1 ).filename;							\
+} else {																		\
+	(Cur).first_line   = (Cur).last_line = YYRHSLOC( Rhs, 0 ).last_line;		\
+	(Cur).first_column = (Cur).last_column = YYRHSLOC( Rhs, 0 ).last_column;	\
+	(Cur).filename     = YYRHSLOC( Rhs, 0 ).filename;							\
+}
 %}
 
 %define parse.error verbose
 
-// Types declaration
+// Types declaration for productions
 %union
 {
@@ -173,4 +170,5 @@
 %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
 %token BOOL COMPLEX IMAGINARY							// C99
+%token INT128 FLOAT80 FLOAT128							// GCC
 %token ZERO_T ONE_T										// CFA
 %token VALIST											// GCC
@@ -1606,28 +1604,34 @@
 
 basic_type_name:
-	CHAR
+	VOID
+		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
+	| BOOL												// C99
+		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
+	| CHAR
 		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Char ); }
+	| INT
+		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); }
+	| INT128
+		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Int128 ); }
+	| FLOAT
+		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); }
+	| FLOAT80
+		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Float80 ); }
+	| FLOAT128
+		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Float128 ); }
 	| DOUBLE
 		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); }
-	| FLOAT
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); }
-	| INT
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); }
-	| LONG
-		{ $$ = DeclarationNode::newLength( DeclarationNode::Long ); }
-	| SHORT
-		{ $$ = DeclarationNode::newLength( DeclarationNode::Short ); }
+	| COMPLEX											// C99
+		{ $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
+	| IMAGINARY											// C99
+		{ $$ = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
 	| SIGNED
 		{ $$ = DeclarationNode::newSignedNess( DeclarationNode::Signed ); }
 	| UNSIGNED
 		{ $$ = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); }
-	| VOID
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
-	| BOOL												// C99
-		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
-	| COMPLEX											// C99
-		{ $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
-	| IMAGINARY											// C99
-		{ $$ = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
+	| SHORT
+		{ $$ = DeclarationNode::newLength( DeclarationNode::Short ); }
+	| LONG
+		{ $$ = DeclarationNode::newLength( DeclarationNode::Long ); }
 	| ZERO_T
 		{ $$ = DeclarationNode::newBuiltinType( DeclarationNode::Zero ); }